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.                  *
 **************************************************************************/
//
// Class for PID QA
// Several studies done on clean samples of electrons, pions and kaons
// coming from V0 PID
// Compatible with both ESDs and AODs
//
// Autors:
//    Matus Kalisky <matus.kalisky@cern.ch>
//    Markus Heide <mheide@uni-muenster.de>
//    Markus Fasel <M.Fasel@gsi.de>
//


#include <TMath.h>
#include <TObjArray.h>
#include <TPDGCode.h>
#include <TString.h>
#include <TMultiLayerPerceptron.h>
#include <TFile.h>

#include "AliAODMCParticle.h"
#include "AliAODEvent.h"
#include "AliAODTrack.h"
#include "AliESDtrack.h"
#include "AliESDEvent.h"
#include "AliMCEvent.h"
#include "AliMCParticle.h"
#include "AliMultiplicity.h"
#include "AliPID.h"
#include "AliPIDResponse.h"
#include "AliVParticle.h"


#include "AliHFEcollection.h"
#include "AliHFEpidQA.h"
#include "AliHFEV0info.h"
#include "AliHFEV0pid.h"
#include "AliHFEV0pidMC.h"
#include "AliHFEV0cuts.h"
#include "AliHFEtrdPIDqa.h"

ClassImp(AliHFEpidQA)

  //__________________________________________
  AliHFEpidQA::AliHFEpidQA():
    fEvent(NULL),
    fMC(NULL), 
    fV0pid(NULL), 
    fV0pidMC(NULL), 
    fTRDpidQA(NULL), 
    fOutput(NULL), 
    fESDpid(NULL),
    fNNref(NULL),
    fTRDTotalChargeInSlice0(kFALSE),
    fIsPbPb(kFALSE),
    fIsppMultiBin(kFALSE)
{
  //
  // Default constructor
  //
  for(Int_t mom = 0; mom < 11; mom++){
    fNet[mom] = NULL;
  }
}

//__________________________________________
AliHFEpidQA::AliHFEpidQA(const AliHFEpidQA &ref):
  TObject(ref),
  fEvent(NULL), 
  fMC(NULL),
  fV0pid(NULL),
  fV0pidMC(NULL), 
  fTRDpidQA(NULL),
  fOutput(NULL), 
  fESDpid(NULL),
  fNNref(NULL),
  fTRDTotalChargeInSlice0(ref.fTRDTotalChargeInSlice0),
  fIsPbPb(kFALSE),
  fIsppMultiBin(kFALSE)
{
  //
  // Copy constructor
  //
  for(Int_t mom = 0; mom < 11; mom++){
    fNet[mom] = NULL;
  }
  ref.Copy(*this);
}

//__________________________________________
AliHFEpidQA &AliHFEpidQA::operator=(const AliHFEpidQA &ref){
  //
  // Assignment operator
  //
  if(this != &ref)
    ref.Copy(*this);
  return *this;
}

//__________________________________________
AliHFEpidQA::~AliHFEpidQA(){
  //
  // Destructor
  //

  // the pointers bellow are not dfeleted to prevend double-deleting of some of the content
  // these pointers are defined only once during the program call and should not cause a problem, 
  // but cleaner solution is necessary.
  //if(fV0pid) delete fV0pid;
  //if(fV0pidMC) delete fV0pidMC;
  //if(fOutput) delete fOutput;

  //  if(fTRDpidResponse) delete fTRDpidResponse; 
}

//__________________________________________
void AliHFEpidQA::Copy(TObject &o) const {
  //
  // Copy function
  //
  
  TObject::Copy(o);

  AliHFEpidQA &target = dynamic_cast<AliHFEpidQA &>(o);
  target.fMC = fMC;
  target.fTRDTotalChargeInSlice0 = fTRDTotalChargeInSlice0;

  if(target.fESDpid) delete target.fESDpid;
  target.fESDpid = fESDpid;
  if(target.fV0pid) delete target.fV0pid;
  if(fV0pid)
    target.fV0pid = dynamic_cast<AliHFEV0pid *>(fV0pid->Clone());
  else
    target.fV0pid = NULL;
  if(target.fV0pidMC) delete target.fV0pidMC;
  if(fV0pidMC) 
    target.fV0pidMC = dynamic_cast<AliHFEV0pidMC *>(fV0pidMC->Clone());
  else
    target.fV0pidMC = NULL;
  if(target.fTRDpidQA) delete target.fTRDpidQA;
  if(fTRDpidQA)
    target.fTRDpidQA = dynamic_cast<AliHFEtrdPIDqa *>(fTRDpidQA->Clone());
  else
    target.fTRDpidQA = NULL;
  if(target.fOutput) delete target.fOutput;
  if(fOutput)
    target.fOutput = dynamic_cast<AliHFEcollection *>(fOutput->Clone());
}

//__________________________________________
void AliHFEpidQA::Init(){
  //
  // Prepare task output
  //

  // load networks
  if(fNNref){
    for(Int_t mom = 0; mom < 11; mom++){                      
      fNet[mom] = (TMultiLayerPerceptron*) fNNref->Get(Form("NN_Mom%d", mom));
      if(!fNet[mom]){
	AliError(Form("No reference network for momentum bin %d!", mom));
      }
    }
  }
  
  fV0pid = new AliHFEV0pid("fV0pid");
  if(HasV0pidQA()) fV0pid->InitQA();
  fV0pidMC = new AliHFEV0pidMC();
  fV0pidMC->Init();

  fTRDpidQA = new AliHFEtrdPIDqa;
  if(fTRDTotalChargeInSlice0) fTRDpidQA->SetTotalChargeInSlice0();
  fTRDpidQA->Init();

  fOutput = new AliHFEcollection("pidQA", "PID QA output");

  const char *name[4] = {"Electron", "PionK0", "PionL", "Proton"};
  const char *title[4] = {"Electron", "K0 Pion", "Lambda Pion", "Proton"};
  const char *det[4] = {"ITS", "TPC", "TRD", "TOF"};
  const int effs[6] = {70, 75, 80, 85, 90, 95};
  for(Int_t i = 0; i < 4; i++){
    fOutput->CreateTH2F(Form("purity%s", name[i]), Form("%s Purity", title[i]), 2, -0.5, 1.5, 20, 0.1, 10, 1);

    for(Int_t idet = 0; idet < 4; idet++){
      // create all the histograms which all the detectors have in common
      if(idet != 2){ // no nSigma histogram for TRD
        fOutput->CreateTH2F(Form("h%s_nSigma_%s", det[idet], name[i]), Form("%s number of sigmas for %ss; p (GeV/c); number of sigmas", det[idet], title[i]), 20, 0.1, 10, 100, -7, 7, 0);
      }
      fOutput->CreateTH2F(Form("h%s_PID_p_%s", det[idet], name[i]), Form("%s PID for %ss; p (GeV/c); ITS PID", det[idet], title[i]), 100, 0.1, 10, 5, -0.5, 4.5, 0);
      fOutput->CreateTH2F(Form("h%s_El_like_%s", det[idet], name[i]), Form("%s Electron Likelihoods for %ss; p (GeV/c); likelihood", det[idet], title[i]), 25, 0.1, 10, 1000, 0., 1., 0);
      fOutput->CreateTH2F(Form("h%s_El_like_MC_%s", det[idet], name[i]), Form("%s Electron Likelihoods for MC %ss; p (GeV/c); likelihood", det[idet], title[i]), 25, 0.1, 10, 1000, 0., 1., 0);
    }

    //
    // ITS pid response
    //
    fOutput->CreateTH2F(Form("hITS_Signal_%s", name[i]), Form("ITS Signal org. for %ss", title[i]), 40, 0.1, 10, 400, 0, 1000, 0);
    fOutput->CreateTH2Fvector1(5, Form("hITS_dEdx_%s", name[i]), Form("ITS dEdx for %ss; p (GeV/c); dEdx (a.u.)", title[i]), 40, 0.1, 10, 400, 0, 1000, 0);
    
    //
    // TPC pid response
    //
    fOutput->CreateTH2F(Form("hTPC_dEdx_%s", name[i]), Form("TPC dEdx for %ss; p (GeV/c); dEdx (a.u.)", title[i]), 20, 0.1, 10, 200, 0, 200, 0);

    //
    // TRD pid response 
    //
    fOutput->CreateTH2F(Form("hTRD_trk_%s", name[i]), Form("%s PID tracklets; p (GeV/c); N TRD tracklets", title[i]), 100, 0.1, 10, 7, -0.5, 6.5, 0);
    // number of the non 0 slices per tracklet
    fOutput->CreateTH2F(Form("hTRD_Nslc_%s", name[i]), Form("%s PID slices > 0; p (GeV/c); N slc > 0", title[i]), 100, 0.1, 10, 9, -0.5, 8.5, 0);
    // location of the slices > 0 - where are the emtpy slices located ?
    fOutput->CreateTH2F(Form("hTRD_slc_%s", name[i]), Form("%s PID slices > 0 position; p (GeV/c); slice", title[i]), 100, 0.1, 10, 9, -0.5, 8.5, 0);
    fOutput->CreateTH2F(Form("hTRD_cls_%s", name[i]), Form("TRD clusters for %s candidates; p (GeV/c); N cls", title[i]), 25, 0.1, 10, 1000, 0, 1000);
    fOutput->CreateTH2F(Form("hTRD_dEdx_%s", name[i]), Form("TRD dEdx (trk) for %s candidates; p (GeV/c); tracklet dEdx (a.u.)", title[i]), 25, 0.1, 10, 1000, 0, 100000, 0);

    for(Int_t itl = 4; itl < 6; itl++){
      for(Int_t ieff = 0; ieff < 6; ieff++){
        fOutput->CreateTH2F(Form("hTRD_likeSel_%s_%dtls_%deff", name[i], itl, effs[ieff]), Form(" %s selected as electrons  with %d tracklets and %f electron efficiency", title[i], itl, static_cast<Double_t>(effs[ieff])/100.), 44, 0.1, 20., 100, 0., 1.);
        fOutput->CreateTH2F(Form("hTRD_likeRej_%s_%dtls_%deff", name[i], itl, effs[ieff]), Form(" %s rejected as electrons  with %d tracklets and %f electron efficiency", title[i], itl, static_cast<Double_t>(effs[ieff])/100.), 44, 0.1, 20., 100, 0., 1.);
      }
    }
    //
    // TOF pid response
    //
    fOutput->CreateTH2F(Form("hTOF_beta_%s", name[i]), Form("TOF beta for %s; p (GeV/c); #beta", title[i]),  50, 0.1, 5, 350, 0.4, 1.1, 0);
  }//.. loop over identified particle species

  // Global histograms
  fOutput->CreateTH1F("hITS_dEdx_nSamples", "ITS - number of non 0 dEdx samples", 4, 0.5, 4.5);
  fOutput->CreateTH2F("hTPC_PID", "TPC pid all tracks; tpc pid probability; species",100, 0, 1, 5, -0.5, 4.5 );
  fOutput->CreateTH2F("hTOF_PID", "TOF pid all tracks; tof pid probability; species",100, 0, 1,5,  -0.5, 4.5 );
  fOutput->CreateTH2F("hTOF_beta_all", "TOF beta for all nice single tracks; p (GeV/c); #beta", 100, 0.1, 10, 480, 0, 1.2, 0);
  fOutput->CreateTH2F("hTOF_qa_TmT0mT", "TOF (t - t0 - t[pion]) qa verus run",  10000, 114000, 124000, 200, -200, 200);
  fOutput->CreateTH2F("hTOF_qa_length", "TOF track length verus run",  10000, 114000, 112400, 200, 0, 1000);
  
  //
  // debug histograms
  //
  fOutput->CreateTH2F("hITS_kFlags", "ITS flags; flag; V0 candidates", 5, 0.5, 5.5, 5, -0.5, 4.5);  
  fOutput->CreateTH2F("hTPC_kFlags", "TPC flags; flag; V0 candidates", 5, 0.5, 5.5, 5, -0.5, 4.5);
  fOutput->CreateTH2F("hTRD_kFlags", "TRD flags; flag; V0 candidates", 5, 0.5, 5.5, 5, -0.5, 4.5);
  fOutput->CreateTH2F("hTOF_kFlags", "TOF flags; flag; V0 candidates", 5, 0.5, 5.5, 5, -0.5, 4.5);
  

  //
  // event based histograms
  //
  Int_t nT0[2] = {10000, 100};
  Double_t minT0[2] = {114500, -1000};
  Double_t maxT0[2] = {124500, 1000};
  fOutput->CreateTHnSparse("hEvent_T0", "T0 as a function of run number; run number; T0 (ns)", 2, nT0, minT0, maxT0);

  //
  // test the tender V0 supply
  //
  fOutput->CreateTH2F("h_tender_check_01", "tender -vs- HFEpidQA; HFEpidQA V0 candiadates; tender V0 candidates", 4, -1.5, 2.5, 4, -1.5, 2.5);
  fOutput->CreateTH2Fvector1(3, "h_tender_check_02", "tender -vs- HFEpidQA per type; AliHFEpidQA V0 ; tender V0", 4, -1.5, 2.5, 4, -1.5, 2.5);


  //
  // THnSpasre objects
  //

  // Create Illumination Plot
  // bins: species, pt, eta, phi, TPC status, TRD status
  {
    Int_t nbins[6] = {4, 40, 16, 72, 2, 2};
    Double_t min[6] = { 0, 0.1, -0.8, 0., 0., 0.};
    Double_t max[6] = { 4., 20., 0.8, 2*TMath::Pi(), 2., 2.};
    fOutput->CreateTHnSparse("hIllumination", "Illumination", 6, nbins, min, max);
    fOutput->BinLogAxis("hIllumination", 1);
  }

  // TPC THnSparse
  // bins: species, pt, n TPC clusters., TPC electron likelihood, TPC n sigmas, TPC signal
  {
    Int_t nbins[6] = { 5, 40, 20, 100, 100, 200};
    Double_t min[6] = { -0.5, 0.1, 0., 0., -5., 0.};
    Double_t max[6] = { 4.5, 20., 200, 1., 5., 120.};
    TString htitle = "TPC info sparse; VO identified species; p (GeV/c); n TPC clusters; TPC N sigma; TPC signal";
    fOutput->CreateTHnSparse("hTPCclusters",htitle,6, nbins, min, max);
    fOutput->BinLogAxis("hTPCclusters", 1);
  }
  // TRD THnSparse - entries per tracklet
  // species, p, tracklet position, number of PID tracklets, number of slices (non 0), number of clusters, electron likelihood, 

  {
    Int_t nbins[7] = {5, 20, 6, 7, 9, 45, 100};
    Double_t min[7] = {-0.5, 0.5, -0.5, -0.5, -0.5, -0.5, 0.};
    Double_t max[7] = {4.5, 10, 5.5, 6.5, 8.5, 179.5, 1.};
    TString htitle = "TRD tracklets; VO identified species; p (GeV/c); tracklet position; No. PID tacklets; No. slices; No. clusters; El. likelihood";
    fOutput->CreateTHnSparse("hTRDtracklets",htitle,7, nbins, min, max);
    fOutput->BinLogAxis("hTRDtracklets", 1);
  }
  

}
//__________________________________________
void AliHFEpidQA::Process(){
  //
  // Run PID QA
  //

  if(!fV0pid){
    AliError("V0pid not available! Forgotten to initialize?");
    return;
  }
  if(!fESDpid){
    AliError("fESDpid not initialized, I am leaving this!");
    return;
  }

  // to be udpated to AOD save mdoe
  if(!fEvent){
    AliError("AliVEvent not available, returning");
  }


  if(fMC) fV0pidMC->SetMCEvent(fMC);
  if(fMC) fV0pid->SetMCEvent(fMC);

  fV0pid->Process(fEvent);
  TObjArray *hfeelectrons = fV0pid->GetListOfElectrons();
  TObjArray *hfepionsK0 = fV0pid->GetListOfPionsK0();
  TObjArray *hfepionsL = fV0pid->GetListOfPionsL();
  TObjArray *hfeprotons = fV0pid->GetListOfProtons();

  // Get Track list for normal purpose
  TObjArray *electrons = MakeTrackList(hfeelectrons);
  TObjArray *pionsK0 = MakeTrackList(hfepionsK0);
  TObjArray *pionsL = MakeTrackList(hfepionsL);
  TObjArray *protons = MakeTrackList(hfeprotons);
  TObjArray *cleanElectrons = MakeCleanListElectrons(hfeelectrons);

  if(fMC){
    fV0pidMC->Process(electrons, AliHFEV0cuts::kRecoElectron);
    fV0pidMC->Process(pionsK0, AliHFEV0cuts::kRecoPionK0);
    fV0pidMC->Process(pionsL, AliHFEV0cuts::kRecoPionL);
    fV0pidMC->Process(protons, AliHFEV0cuts::kRecoProton);
  }

  AliDebug(2, Form("Number of Electrons      : %d", electrons->GetEntries()));
  AliDebug(2, Form("Number of K0 Pions       : %d", pionsK0->GetEntries()));
  AliDebug(2, Form("Number of Lambda Pions   : %d", pionsL->GetEntries()));
  AliDebug(2, Form("Number of Protons        : %d", protons->GetEntries()));
  if(fMC){
    AliDebug(2, "MC Information available. Doing Purity checks...");
    // Calculate the purity of the clean samples using MC 
    MakePurity(electrons, AliHFEV0cuts::kRecoElectron);
    MakePurity(pionsK0,  AliHFEV0cuts::kRecoPionK0);
    MakePurity(pionsL,  AliHFEV0cuts::kRecoPionL);
    MakePurity(protons,  AliHFEV0cuts::kRecoProton);
  }

  // some event wise checks
  CheckEvent();

  // Make Illumination Plot
  FillIllumination(electrons, AliHFEV0cuts::kRecoElectron);
  FillIllumination(pionsK0, AliHFEV0cuts::kRecoPionK0);
  FillIllumination(pionsL, AliHFEV0cuts::kRecoPionL);
  FillIllumination(protons, AliHFEV0cuts::kRecoProton);

  // Now we can do studies on the PID itself
  // For TRD use the TRD PID QA object
  Int_t centrality=-1;
  if(fIsPbPb) centrality=GetCentrality(fEvent);
  if(fIsppMultiBin) centrality=GetMultiplicityITS(fEvent);
  fTRDpidQA->SetCentralityBin(centrality);
  fTRDpidQA->ProcessTracks(cleanElectrons, AliPID::kElectron);
  fTRDpidQA->ProcessTracks(pionsK0, AliPID::kPion);
  fTRDpidQA->ProcessTracks(pionsL, AliPID::kPion);
  fTRDpidQA->ProcessTracks(protons, AliPID::kProton);

  // Monitor TRD PID Response
  /*TestTRDResponse(cleanElectrons, AliHFEV0cuts::kRecoElectron);
  TestTRDResponse(pionsK0, AliHFEV0cuts::kRecoPionK0);
  TestTRDResponse(pionsL, AliHFEV0cuts::kRecoPionL);
  TestTRDResponse(protons, AliHFEV0cuts::kRecoProton);*/

  FillElectronLikelihoods(electrons,  AliHFEV0cuts::kRecoElectron); 
  FillElectronLikelihoods(pionsK0,  AliHFEV0cuts::kRecoPionK0); 
  FillElectronLikelihoods(pionsL,  AliHFEV0cuts::kRecoPionL); 
  FillElectronLikelihoods(protons,  AliHFEV0cuts::kRecoProton); 
  
  FillPIDresponse(electrons, AliHFEV0cuts::kRecoElectron);
  FillPIDresponse(pionsK0, AliHFEV0cuts::kRecoPionK0);
  FillPIDresponse(pionsL, AliHFEV0cuts::kRecoPionL);
  FillPIDresponse(protons, AliHFEV0cuts::kRecoProton);

  // check the tender V0s
  CheckTenderV0pid(electrons, AliHFEV0cuts::kRecoElectron);
  CheckTenderV0pid(pionsK0, AliHFEV0cuts::kRecoPionK0);
  CheckTenderV0pid(pionsL, AliHFEV0cuts::kRecoPionL);
  CheckTenderV0pid(protons, AliHFEV0cuts::kRecoProton);

  // Analysis done, flush the containers
  fV0pid->Flush();

  delete electrons;
  delete pionsL;
  delete pionsK0;
  delete protons;
  delete cleanElectrons;
}

//__________________________________________
void AliHFEpidQA::FillIllumination(const TObjArray * const tracks, Int_t species){
  //
  // Fill Illumination Plot
  //
  THnSparseF *hIllumination = dynamic_cast<THnSparseF *>(fOutput->Get("hIllumination"));
  if(!hIllumination) return;

  Double_t quantities[6]; memset(quantities, 0, sizeof(Double_t) *6);
  TIter trackIter(tracks);

  quantities[0] = species;
  TObject *o = NULL; AliESDtrack *esdtrack = NULL;
  while((o = trackIter())){
    if(!TString(o->IsA()->GetName()).CompareTo("AliESDtrack")){
      // work on local copy in order to not spoil others
      esdtrack = new AliESDtrack(*(static_cast<AliESDtrack *>(o)));  
      if(!esdtrack) continue;
    } else if(!TString(o->IsA()->GetName()).CompareTo("AliAODrack")){
      // Bad hack: Fill ESD track with AOD information
      esdtrack = new AliESDtrack(static_cast<AliAODTrack *>(o));
      if(!esdtrack) continue;
    } else {
      // Non usable
      continue;
    }

    // Propagate to the entrance of the TRD
    esdtrack->PropagateTo(300, fEvent->GetMagneticField());
    quantities[1] = esdtrack->Pt();
    quantities[2] = esdtrack->Eta();
    quantities[3] = esdtrack->Phi();
    quantities[4] = (esdtrack->GetStatus() & AliESDtrack::kTPCrefit) ? 1 : 0;
    quantities[5] = (esdtrack->GetStatus() & AliESDtrack::kTRDout) ? 1. : 0.;
    hIllumination->Fill(quantities);

    delete esdtrack;
  }
}
//__________________________________________
void AliHFEpidQA::FillTPCinfo(AliESDtrack *const esdtrack, Int_t species){
  //
  // Fill TPC Cluster Plots
  //
  THnSparseF *hTPCclusters = dynamic_cast<THnSparseF *>(fOutput->Get("hTPCclusters"));
  if(!hTPCclusters) return;

  Double_t quantities[6]; memset(quantities, 0, sizeof(Double_t) *6);
  
  Double_t pidProbs[5];
  const Int_t typePID[5] = {0, 2, 2, 3, 4};


  quantities[0] = species;

  
  esdtrack->GetTPCpid(pidProbs);   
    
  quantities[1] = esdtrack->P();
  quantities[2] = esdtrack->GetTPCNcls();
  quantities[3] = pidProbs[0];
  quantities[4] = fESDpid->NumberOfSigmasTPC(esdtrack,(AliPID::EParticleType)typePID[species]);
  quantities[5] = esdtrack->GetTPCsignal();
  hTPCclusters->Fill(quantities);

}

//__________________________________________
void AliHFEpidQA::TestTRDResponse(const TObjArray * const tracks, Int_t species){
  //
  // Test PID Response function of the TRD
  //
  Int_t effInt[6] = {70, 75, 80, 85, 90, 95};
  const char *sname[5] = {"Electron", "PionK0", "PionL", "Kaon", "Proton"};
  AliESDtrack *track = NULL;
  TIter trackIter(tracks);
  Float_t momenta[6], p;
  Int_t nmomenta;
  Double_t probs[5], likeEl;
  while((track = static_cast<AliESDtrack *>(trackIter()))){
    if(track->GetTRDntrackletsPID() < 4) continue;

    // calculate momentum at TRD level
    memset(momenta, 0, sizeof(Float_t) * 6); nmomenta = 0;
    for(Int_t ily = 0; ily < 6; ily++){
      if(track->GetTRDmomentum(ily) > 0.01) momenta[nmomenta++] = track->GetTRDmomentum(ily);
    }
    p = TMath::Mean(nmomenta, momenta);

    // Get Electron likelihood
    track->GetTRDpid(probs);
    likeEl = probs[0]/(probs[0] + probs[2]);

    for(Int_t ieff = 0; ieff < 6; ieff++){
      if(fESDpid->IdentifiedAsElectronTRD(track, static_cast<Double_t>(effInt[ieff])/100.)) fOutput->Fill(Form("hTRD_likeSel_%s_%dtls_%deff", sname[species], static_cast<Int_t>(track->GetTRDntrackletsPID()), effInt[ieff]), p, likeEl);
      else fOutput->Fill(Form("hTRD_likeRej_%s_%dtls_%deff", sname[species], static_cast<Int_t>(track->GetTRDntrackletsPID()), effInt[ieff]), p, likeEl);
    }
  }
}

//__________________________________________
void AliHFEpidQA::MakePurity(const TObjArray *tracks, Int_t species){
  //
  // Fill the QA histos for a given species
  //
  if(!fMC) return;
  AliDebug(3, Form("Doing Purity checks for species %d", species));
  Int_t pdg = GetPDG(species);
  TString hname;

  switch(species){
  case  AliHFEV0cuts::kRecoElectron:
    hname = "purityElectron";
    break;
  case  AliHFEV0cuts::kRecoPionK0:
    hname = "purityPionK0";
    break;
  case  AliHFEV0cuts::kRecoPionL:
    hname = "purityPionL";
    break;
  case  AliHFEV0cuts::kRecoProton:
    hname = "purityProton";
    break;
  default:  // non investigated species
    AliDebug(3, "Species not investigated");
    return;
  }  

  AliDebug(3, Form("Number of tracks: %d", tracks->GetEntries()));
  TIter trackIter(tracks);
  AliVParticle *recTrack = NULL, *mcTrack = NULL;
  while((recTrack = dynamic_cast<AliVParticle *>(trackIter()))){
    Int_t label = recTrack->GetLabel();
    AliDebug(4, Form("MC Label %d", label));
    mcTrack =fMC->GetTrack(TMath::Abs(label));
    if(!mcTrack){
      AliDebug(4, "MC track not available");
      continue; // we don't know
    }

    // Get the pdg code
    Int_t trackPdg = 0;
    if(!TString(mcTrack->IsA()->GetName()).CompareTo("AliMCParticle")){
      // case ESD
      AliMCParticle *mcp = dynamic_cast<AliMCParticle *>(mcTrack);
      if(!mcp) continue;
      trackPdg = TMath::Abs(mcp->Particle()->GetPdgCode());
    } else {
      // case AOD
      AliAODMCParticle *aodmcp = dynamic_cast<AliAODMCParticle *>(mcTrack);
      if(!aodmcp) continue;
      trackPdg = TMath::Abs(aodmcp->GetPdgCode());
    }
    if(trackPdg == pdg)    // Correct identification
      {
	fOutput->Fill(hname, 0., recTrack->Pt());
      }
    else  // Wrong identification
      fOutput->Fill(hname, 1., recTrack->Pt());
  }
}

//__________________________________________
void AliHFEpidQA::FillElectronLikelihoods(const TObjArray * const particles, Int_t species){
  //
  // Fill electron Likelihoods for the ITS, TPC and TOF
  // Required for the calculation of the electron efficiency, 
  // pion and proton efficiency and the thresholds
  //
  Long_t status = 0;
  const TString detname[4] = {"ITS", "TPC", "TRD", "TOF"};
  TString specname;

  switch(species){
  case  AliHFEV0cuts::kRecoElectron:
    specname = "Electron";
    break;
  case  AliHFEV0cuts::kRecoPionK0:
    specname = "PionK0";
    break;
  case  AliHFEV0cuts::kRecoPionL:
    specname = "PionL";
    break;
  case  AliHFEV0cuts::kRecoProton:
    specname = "Proton";
    break;
  default:
    AliDebug(2, Form("Species %d not investigated", species));
    return;
  };
  AliVParticle *recTrack = NULL;
  //  mcTrack =fMC->GetTrack(TMath::Abs(label));
  //   if(!mcTrack){
  //     AliDebug(4, "MC track not available");
  //     continue; // we don't know
  //   }

  TIter trackIter(particles);

  Double_t quantities[2];
  Double_t pidProbs[5];

  while((recTrack = dynamic_cast<AliVParticle *>(trackIter()))){
    if(!TString(recTrack->IsA()->GetName()).CompareTo("AliESDtrack")){
      // case ESD
      AliESDtrack *esdTrack = dynamic_cast<AliESDtrack *>(recTrack);
      if(!esdTrack) continue;
      status = esdTrack->GetStatus();

      //TPC momentum and likelihoods
      Double_t pTPC = 0.;
      pTPC = esdTrack->GetInnerParam() ? esdTrack->GetInnerParam()->P() : esdTrack->P();
      Bool_t mcFound = kFALSE;
      if(fMC){
	Int_t label = esdTrack->GetLabel();
	AliMCParticle *mcTrack = dynamic_cast<AliMCParticle *>(fMC->GetTrack(label));
	Int_t pdg = GetPDG(species);
	Int_t trackPdg = 0; 
	if(mcTrack){
	  trackPdg = TMath::Abs(mcTrack->Particle()->GetPdgCode());
	}
	if(pdg == trackPdg) mcFound = kTRUE;	
      }
      quantities[0] = pTPC;
      Bool_t detFlagSet = kFALSE;
      for(Int_t idet = 0; idet < 4; idet++){
        TString histname, histnameMC;
	histname = "h" + detname[idet] + "_El_like_" + specname;
	histnameMC = "h" + detname[idet] + "_El_like_MC_" + specname;

        switch(idet){
          case kITS:  esdTrack->GetITSpid(pidProbs);
                      detFlagSet = status & AliESDtrack::kITSpid;
                      break;
          case kTPC:  esdTrack->GetTPCpid(pidProbs);
                      detFlagSet = status & AliESDtrack::kTPCpid;
                      break;
          case kTRD:  esdTrack->GetTRDpid(pidProbs);
                      detFlagSet = status & AliESDtrack::kTRDpid;
                      break;
          case kTOF:  esdTrack->GetTOFpid(pidProbs);  
                      detFlagSet = status & AliESDtrack::kTOFpid;
                      break;
        };
        quantities[1] = pidProbs[AliPID::kElectron];
	// in case of TRD require 6 PID tracklets
	if(kTRD == idet && esdTrack->GetTRDntrackletsPID() != 6) continue;
        if(detFlagSet){
	  fOutput->Fill(histname, quantities[0], quantities[1]);
	  if(mcFound)
	    fOutput->Fill(histnameMC, quantities[0], quantities[1]);
        }
      }
    }//.. ESD
    else{
      //AOD
    }//.. aod 
  }//.. while tracks 
}
//__________________________________________
void AliHFEpidQA::FillPIDresponse(const TObjArray * const particles, Int_t species){
  //
  // Fill the PID response of different detectors to V0 daughter particles
  //
  TString hname, hname2, hname3;
   
  const TString typeName[5] = {"Electron", "PionK0", "PionL", "Kaon", "Proton"};
  const Int_t typePID[5] = {0, 2, 2, 3, 4};

  // PID THnSparse
  // axes:
  // 0) species,  1) momentum, 2) DCA xy, 3) DCA z 
  // 4) ITS signal 
  // 5) TPC Ncls 6) TPC signal 7) TPC nSigma, 
  // 8) TRD Ntrk, 9) TRD Ncls, 10) TRD dEdx, 

  //Double_t data[12];
 

  Int_t run = fEvent->GetRunNumber();
    
  AliVParticle *recTrack = NULL;
  TIter trackIter(particles); 
  while((recTrack = dynamic_cast<AliVParticle *>(trackIter()))){
    //for(Int_t i=0; i<12; ++i) data[i] = -99.;
    // ESD
    if(!TString(recTrack->IsA()->GetName()).CompareTo("AliESDtrack")){
      // case ESD
      AliESDtrack *esdTrack = dynamic_cast<AliESDtrack *>(recTrack);
      if(!esdTrack) continue;
      
      // for the PID THnSparse
      //data[0] = species;
      //data[1] = esdTrack->P();
      Float_t impactR = -1.;
      Float_t impactZ = -1.;
      esdTrack->GetImpactParameters(impactR, impactZ);
      //data[2] = impactR;
      //data[3] = impactZ;
      //data[11] = 0; // initialize the TOF pid cut on elecgrons to false
      // use ONLY tracks with PID flag TRUE
      ULong_t status = 0;
      status = esdTrack->GetStatus();

      //
      // DEBUG 
      //
      
      fOutput->Fill("hITS_kFlags", 5., species);
      if(status & AliESDtrack::kITSin)    fOutput->Fill("hITS_kFlags", 1., species);
      if(status & AliESDtrack::kITSout)   fOutput->Fill("hITS_kFlags", 2., species);
      if(status & AliESDtrack::kITSrefit) fOutput->Fill("hITS_kFlags", 3., species);
      if(status & AliESDtrack::kITSpid)   fOutput->Fill("hITS_kFlags", 4., species);
      
      fOutput->Fill("hTPC_kFlags", 5., species);
      if(status & AliESDtrack::kTPCin)    fOutput->Fill("hTPC_kFlags", 1., species);
      if(status & AliESDtrack::kTPCout)   fOutput->Fill("hTPC_kFlags", 2., species);
      if(status & AliESDtrack::kTPCrefit) fOutput->Fill("hTPC_kFlags", 3., species);
      if(status & AliESDtrack::kTPCpid)   fOutput->Fill("hTPC_kFlags", 4., species);

      fOutput->Fill("hTRD_kFlags", 5., species);
      if(status & AliESDtrack::kTRDin)    fOutput->Fill("hTRD_kFlags", 1., species);
      if(status & AliESDtrack::kTRDout)   fOutput->Fill("hTRD_kFlags", 2., species);
      if(status & AliESDtrack::kTRDrefit) fOutput->Fill("hTRD_kFlags", 3., species);
      if(status & AliESDtrack::kTRDpid)   fOutput->Fill("hTRD_kFlags", 4., species);

      fOutput->Fill("hTOF_kFlags", 5., species);
      if(status & AliESDtrack::kTOFin)    fOutput->Fill("hTOF_kFlags", 1., species);
      if(status & AliESDtrack::kTOFout)   fOutput->Fill("hTOF_kFlags", 2., species);
      if(status & AliESDtrack::kTOFrefit) fOutput->Fill("hTOF_kFlags", 3., species);
      if(status & AliESDtrack::kTOFpid)   fOutput->Fill("hTOF_kFlags", 4., species);

      
      //
      // ITS - 
      //
      if(status & AliESDtrack::kITSpid){
	Double_t p = esdTrack->P();

	// ITS signal
	//Double_t itsSignal = esdTrack->GetITSsignal();
	
	// ITS dEdx
	Double_t dEdxSamples[4];
	esdTrack->GetITSdEdxSamples(dEdxSamples);
	Int_t nSamples = 0;
	Double_t dEdxSum = 0.;
	hname = "hITS_dEdx_" + typeName[species];
	for(Int_t i=0; i<4; ++i){
	  if(dEdxSamples[i] > 0){
	    nSamples++;
	    fOutput->Fill(hname, i+1, p, dEdxSamples[i]);
	    dEdxSum += dEdxSamples[i];
	  }
	}
	if(4 == nSamples)fOutput->Fill(hname, 0, p, dEdxSum);
	fOutput->Fill("hITS_dEdx_nSamples", nSamples);

	Double_t signal = esdTrack->GetITSsignal();
	hname = "hITS_Signal_" + typeName[species];
	fOutput->Fill(hname, p, signal);
	//data[4] = signal;
	
	// ITS number of signas
	Double_t nsigma = fESDpid->NumberOfSigmasITS(esdTrack,(AliPID::EParticleType)typePID[species]);
	hname = "hITS_nSigma_" + typeName[species];
	fOutput->Fill(hname, p, nsigma);
	// ITS PID response
	Double_t itsPID[5] = {-1, -1, -1, -1, -1};
	esdTrack->GetITSpid(itsPID);
	Int_t ix = GetMaxPID(itsPID);
	hname = "hITS_PID_p_" + typeName[species];
	fOutput->Fill(hname, p, ix);
      }//.. kITSpid
      
      //
      // TPC
      //
      if(status & AliESDtrack::kTPCpid){
	// Make TPC clusters Plot
	//data[5] = esdTrack->GetTPCNcls();
	FillTPCinfo(esdTrack, species);

	Double_t p = esdTrack->GetInnerParam() ? esdTrack->GetInnerParam()->P() : esdTrack->P();
	// TPC dEdx
	Double_t dEdx = esdTrack->GetTPCsignal();
	hname = "hTPC_dEdx_" + typeName[species];
	fOutput->Fill(hname, p, dEdx);
	//data[6] = dEdx;
	
	//TPC number of sigmas
	Double_t nsigma = fESDpid->NumberOfSigmasTPC(esdTrack,(AliPID::EParticleType)typePID[species]);
	hname = "hTPC_nSigma_" + typeName[species];
	fOutput->Fill(hname, p, nsigma);
	//data[7] = nsigma;

	// TPC PID response
	hname = "hTPC_PID_p_" + typeName[species];
	Double_t tpcPID[5] = {-1, -1, -1, -1, -1};
	esdTrack->GetTPCpid(tpcPID);
	Int_t ix = GetMaxPID(tpcPID);
	fOutput->Fill(hname, p, ix);	
      }//.. kTPCpid
      
      //
      // TRD
      //
      
      if(status & AliESDtrack::kTRDpid){
	Double_t p = esdTrack->GetOuterParam() ? esdTrack->GetOuterParam()->P() : esdTrack->P();
	
	// TRD number of tracklets
	Int_t ntrk = esdTrack->GetTRDntrackletsPID();
	hname = "hTRD_trk_" + typeName[species];
	fOutput->Fill(hname, p, ntrk);
	//data[8] = ntrk;

	// TRD PID response
	hname = "hTRD_PID_p_" + typeName[species];
	Double_t trdPID[5] = {-1., -1., -1., -1., -1};
	esdTrack->GetTRDpid(trdPID);
	Int_t ix = GetMaxPID(trdPID);
	fOutput->Fill(hname, p, ix);
	// TRD n clusters
	Int_t ncls = esdTrack->GetTRDncls();
	hname = "hTRD_cls_" + typeName[species];
	fOutput->Fill(hname, p, ncls);
	//data[9] = ncls;

	// TRD - per tracklet - dEdx per, likelihood
	hname = "hTRD_Nslc_" + typeName[species];
	hname2 = "hTRD_slc_" + typeName[species];
	hname3 = "hTRD_dEdx_" + typeName[species];
	Int_t nSlices = esdTrack->GetNumberOfTRDslices();
	Double_t sumTot = 0.;
	Int_t not0Tot = 0;
	for(Int_t l=0; l< 6; ++l){
	  Double_t trkData[7] = {-1.,-1, -1, -1, -1, -1, -1};
	  trkData[0] = species;
	  trkData[1] = p;
	  trkData[2] = l;
	  trkData[3] = ntrk;
	  trkData[5] = ncls;	    
	  Double_t sum = 0.;
	  Int_t not0 = 0;
	  for(Int_t s=0; s<nSlices; ++s){
	    Double_t slice = esdTrack->GetTRDslice(l, s);
	    sum += slice;
	    if(slice > 0){
	      not0 += 1;
	      fOutput->Fill(hname2, p, s);
	    }
	  }//..slices

	  trkData[4] = not0;
	  fOutput->Fill(hname, p, not0);
	  fOutput->Fill(hname3, p, sum);
	  if(sum > 0){
	    sumTot += sum;
	    not0Tot += 1;
	  }
	  // lkelihoods per layer
	  if(not0Tot > 0 && fNNref){
	    Double_t likelihoods[5] = {-1., -1., -1., -1., -1};
	    TRDlikeTracklet(l, esdTrack, likelihoods);
	    trkData[6] = likelihoods[0];
	    //printf(" -D: species: %i, P; %f : %f, s: %f\n", species, p, likelihoods[0], s);
	  }
	  if(not0Tot) fOutput->Fill("hTRDtracklets", trkData);
	}//..layers
	// average dEx per number of tracklets
	//if(0 < not0Tot)
	//  data[10] = sumTot / not0Tot;
      }//.. kTRDpid
      
      
      //
      // TOF
      //
      if(status & AliESDtrack::kTOFpid){
	Double_t p = esdTrack->GetOuterParam() ? esdTrack->GetOuterParam()->P() : esdTrack->P();
	Double_t t0 = fESDpid->GetTOFResponse().GetStartTime(esdTrack->P());

	//TOF beta
	hname = "hTOF_beta_" + typeName[species];
	Float_t beta = TOFbeta(esdTrack);	
	fOutput->Fill(hname, p, beta);
	fOutput->Fill("hTOF_beta_all", p, beta);
	// TOF nSigma
	Double_t nsigma = fESDpid->NumberOfSigmasTOF(esdTrack,(AliPID::EParticleType)typePID[species]);
	hname = "hTOF_nSigma_" + typeName[species];
	fOutput->Fill(hname, p, nsigma);
	//if(beta > 0.97 && beta < 1.03){
	//  data[11] = 1;
	//}
	
	// TOF PID response
	hname = "hTOF_PID_p_" + typeName[species];
	Double_t tofPID[5] = {-1., -1., -1., -1., -1};
	esdTrack->GetTOFpid(tofPID);
	Int_t ix = GetMaxPID(tofPID);
	fOutput->Fill(hname, p, ix);
	
	// time of flight QA
	// - distribution of (time - t0 - pion_time)
	Double_t times[AliPID::kSPECIESC];
	esdTrack->GetIntegratedTimes(times);
	Double_t tItrackL = esdTrack->GetIntegratedLength();
	Double_t tTOFsignal = esdTrack->GetTOFsignal();
	Double_t dT = tTOFsignal - t0 - times[2];
	fOutput->Fill("hTOF_qa_TmT0mT", run*1.0, dT);
	fOutput->Fill("hTOF_qa_length", run*1.0, tItrackL);

	
      }//.. kTOFpid
      // temporary - the PIDsparse needs rebuilding
      //fOutput->Fill("PIDsparse", data);
    }
    // AOD - comming soon
    else{
      continue;
    }
  }// .. tracks in TObjArray
  

}
//__________________________________________
void AliHFEpidQA:: CheckEvent(){
  //
  // check some event variables
  //

  // check the T0 as a function of run number (less than one bin per number
  Double_t t0 = fESDpid->GetTOFResponse().GetTimeZero();
  Int_t run = fEvent->GetRunNumber();
  Double_t data[2] = {run*1.0, t0*1000.};
  fOutput->Fill("hEvent_T0", data);
  

}
//__________________________________________
TList *AliHFEpidQA::GetOutput(){
  //
  // Getter for Output histograms
  //
  return fOutput->GetList();
}

//__________________________________________
TList *AliHFEpidQA::GetV0pidQA(){
  //
  // Getter for V0 PID QA histograms
  //
  return fV0pid->GetListOfQAhistograms();
}

//__________________________________________
TList *AliHFEpidQA::GetV0pidMC(){
  //
  // Getter for V0 PID QA histograms
  //
  if(fV0pidMC)
    return fV0pidMC->GetListOfQAhistograms();
  return NULL;
}

//__________________________________________
void AliHFEpidQA::RecalculateTRDpid(AliESDtrack * /*track*/, Double_t * /*pidProbs*/) const{
  //  fTRDpidResponse->MakePID(track);
  //  track->GetTRDpid(pidProbs);
}

//__________________________________________
void AliHFEpidQA::RecalculateTRDpid(AliAODTrack * /*track*/, Double_t * /*pidProbs*/) const{
  //  fTRDpidResponse->MakePID(track, pidProbs);
}
//___________________________________________________________________
Float_t AliHFEpidQA::TOFbeta(const AliESDtrack * const track) const {
  // computes the TOF beta
  Double_t l = track->GetIntegratedLength();  // cm
  Double_t t = track->GetTOFsignal();
  Double_t t0 = fESDpid->GetTOFResponse().GetTimeZero(); // ps

  //printf("-D: l: %f, t: %f, t0: %f\n", l, t, t0);

  if(l < 360. || l > 800.) return 0.;
  if(t <= 0.) return 0.;
  if(t0 >999990.0) return 0.;
  

  t -= t0; // subtract the T0

  l *= 0.01;  // cm ->m
  t *= 1e-12; //ps -> s

  
  Double_t v = l / t;
  Float_t beta = v / TMath::C();

  return beta;
}
//____________________________________________
Int_t AliHFEpidQA::GetMaxPID(const Double_t *pidProbs) const {
  //
  // return the index of maximal PID probability
  //
  Int_t ix = -1;
  Double_t tmp = 0.2;
  for(Int_t i=0; i<5; ++i){
    if(pidProbs[i] > tmp){
      ix = i;
      tmp = pidProbs[i];
    }
  }
  return ix;
}
//_____________________________________________
Int_t AliHFEpidQA::GetPDG(Int_t species){
  //
  // return the PDG particle code
  //

  Int_t pdg = 0;

  switch(species){
  case  AliHFEV0cuts::kRecoElectron:
    pdg = TMath::Abs(kElectron);
    break;
  case  AliHFEV0cuts::kRecoPionK0:
    pdg = TMath::Abs(kPiPlus);
    break;
  case  AliHFEV0cuts::kRecoPionL:
    pdg = TMath::Abs(kPiPlus);
    break;
  case  AliHFEV0cuts::kRecoProton:
    pdg = TMath::Abs(kProton);
    break;
  default:  // non investigated species
    AliDebug(3, "Species not recognised");
    return 0;
  }  

  return pdg;

}

//_____________________________________________
TObjArray * AliHFEpidQA::MakeTrackList(const TObjArray *tracks) const {
  //
  // convert list of AliHFEV0Info into a list of AliVParticle
  //
  TObjArray *output = new TObjArray;
  TIter trackInfos(tracks);
  AliHFEV0info *trackInfo = NULL;
  while((trackInfo = dynamic_cast<AliHFEV0info *>(trackInfos())))
    output->Add(trackInfo->GetTrack());

  return output;
}

//_____________________________________________
TObjArray * AliHFEpidQA::MakeCleanListElectrons(const TObjArray *electrons) const {
  //
  // Cleanup electron sample using TPC PID
  // PID requirement will allways be implemented to the pair
  // Strategy
  //
  TObjArray *tracks = new TObjArray;
  TIter candidates(electrons);
  AliESDEvent *esd; 
  //AliAODEvent *aod;
  AliHFEV0info *hfetrack;
  // const Double_t kSigmaTight = 1.;
  // const Double_t kSigmaLoose = 4.;
  const Double_t kSigmaTight = 2.;
  const Double_t kSigmaLoose = 2.;
  const Double_t shift = 0.57;
  if((esd = dynamic_cast<AliESDEvent *>(fEvent))){
    AliESDtrack *track = NULL, *partnerTrack = NULL;
    while((hfetrack = dynamic_cast<AliHFEV0info *>(candidates()))){
      track = dynamic_cast<AliESDtrack *>(hfetrack->GetTrack());
      if(!track) continue;
      partnerTrack = esd->GetTrack(hfetrack->GetPartnerID());
      Double_t nSigmaTrack = TMath::Abs(fESDpid->NumberOfSigmasTPC(track, AliPID::kElectron) - shift);
      Double_t nSigmaPartner = TMath::Abs(fESDpid->NumberOfSigmasTPC(partnerTrack, AliPID::kElectron) - shift);
      if((nSigmaTrack < kSigmaTight && nSigmaPartner < kSigmaLoose) || (nSigmaTrack < kSigmaLoose && nSigmaPartner < kSigmaTight))
        tracks->Add(track);
    }
  } 
  /*else {
    aod = dynamic_cast<AliAODEvent *>(fEvent);
    if(!aod) return NULL;
    //AliAODTrack *track = NULL, *partnerTrack = NULL;
    while((hfetrack = dynamic_cast<AliHFEV0info *>(candidates()))){
      if(!hfetrack) continue;
      //track = dynamic_cast<AliAODTrack *>(hfetrack->GetTrack());
      //partnerTrack = aod->GetTrack(hfetrack->GetPartnerID());
      // will be coming soon
    }
  }*/
  return tracks;
}
//___________________________________________________________
void AliHFEpidQA::CheckTenderV0pid(const TObjArray * const particles, Int_t species){

  //
  // retrieve the status bits from the TObject used to flag
  // the V0 daughter tracks and return the found PID
  // 0 - electron, 1 - pion, 2 - proton
  // 

  const Int_t id[5] = {0, 1, 1, -1, 2}; // convert AliHFEpid to simple 0, 1, 2

  AliVParticle *recTrack = NULL;
  TIter trackIter(particles); 
  while((recTrack = dynamic_cast<AliVParticle *>(trackIter()))){
    if(!TString(recTrack->IsA()->GetName()).CompareTo("AliESDtrack")){
      // case ESD
      AliESDtrack *track = dynamic_cast<AliESDtrack *>(recTrack);
      if(!track) continue;
      Int_t tPID = GetTenderV0pid(track);
      fOutput->Fill("h_tender_check_01", id[species]*1.0, tPID);
      fOutput->Fill("h_tender_check_02", id[species], id[species]*1.0, tPID);
      
    } //.. case ESD      
    
  }//.. iterate of tracks  
}
//___________________________________________________________
Int_t AliHFEpidQA::GetTenderV0pid(AliESDtrack * const track){
  //
  // retrieve the PID nformation stored in the status flags by the train tender
  //
  

  Int_t pid = -1;
  if(!track){
    return pid;
  }
  
  Int_t nTimes = 0;
  
  if(track->TestBit(2<<14)){
    pid = 0;
    nTimes++;
  }
  if(track->TestBit(2<<15)){
    pid = 1;
    nTimes++;
  }
  if(track->TestBit(2<<16)){
    pid = 2;
    nTimes++;
  }
  
  if(nTimes > 1){
    AliWarning("V0 track labeled multiple times by the V0 tender");
    pid = -1;
  }
    
  return pid;

}
//___________________________________________________________
Double_t AliHFEpidQA::TRDlikeTracklet(Int_t layer, AliESDtrack * const track, Double_t *likelihood){
  //
  // compute the TRD electron likelihoods for 1 tracklet
  // based on teh AliTRDpidRecalculator in train/until/tender
  // returns sum of the likelihoods (which should be 1)
  //

  const Double_t cScaleGain = 1./ 16000.;
  const Float_t pBins[11] ={0.6, 0.8, 1.0, 1.5, 2.0, 3.0, 4.0, 5.0, 6.0, 8.0, 10.0}; // momentum bins

  if(!track) return kFALSE;
  Float_t p = track->GetTRDmomentum(layer); // momentum for a tracklet in the ESDtrack
  if(p < 0) return kFALSE;

  Int_t mombin = TRDmomBin(p);  // momentum bin
  if(mombin < 0) return -1.;
  Float_t dEdxTRDsum = 0;              // dEdxTRDsum for checking if tracklet is available
  Float_t dEdxTRD[8];           // dEdx for a tracklet in the ESD slices
  Double_t ddEdxTRD[8];         // dEdx as Double_t for TMultiLayerPerceptron::Evaluate()
  
  Double_t prob[AliPID::kSPECIES];  // probabilities for all species in all layers

  for(Int_t is = 0; is < AliPID::kSPECIES; is++){
    likelihood[is] = 0.2;               // init probabilities
    prob[is] = 0.2; 
  }

  Double_t sum = 0.;

  for(Int_t islice = 0; islice<8; islice++){
    dEdxTRD[islice]=0.;                                    // init dE/dx
    ddEdxTRD[islice]=0.;                                   // init dE/dx
    dEdxTRD[islice]=track->GetTRDslice(layer,islice);       // get the dE/dx values
    dEdxTRDsum += dEdxTRD[islice];
    ddEdxTRD[islice]=(Double_t)dEdxTRD[islice]*cScaleGain;            // rescale dE/dx
    
  }
  for(Int_t is = 0; is < AliPID::kSPECIES; is++){
    Double_t probloc1, probloc2; 
    if(mombin == 0 && mombin < pBins[0]){          //  calculate PID for p > 0.6 GeV/c
      prob[is] = fNet[mombin]->Evaluate(is, ddEdxTRD);
    }
    else if(mombin == 10 && mombin >= pBins[10]){   //  calculate PID for p >= 10.0 GeV/c
      prob[is] = fNet[mombin]->Evaluate(is, ddEdxTRD);
    }
    else{                                                    //  standard calculation
      Int_t mombin1 = 0, mombin2 = 0;             // lower and upper momentum bin      
      if(p < pBins[mombin]) {mombin1 = mombin -1; mombin2 = mombin;}
      if(p >= pBins[mombin]) {mombin1 = mombin; mombin2 = mombin+1;}
      probloc1 = fNet[mombin1]->Evaluate(is, ddEdxTRD);
      probloc2 = fNet[mombin2]->Evaluate(is, ddEdxTRD);
      // weighting of the probability with regard to the track momentum
      prob[is] = probloc1 + (probloc2-probloc1)*(p-pBins[mombin1])/(pBins[mombin2]-pBins[mombin1]);
    }
    likelihood[is] = prob[is];
    sum += likelihood[is];
  }     
  
  return sum;
}
//__________________________________________________________________________
Int_t AliHFEpidQA::TRDmomBin(Double_t p) const {
  //
  // compute the momentum bin position
  // 

  const Float_t pBins[11] ={0.6, 0.8, 1.0, 1.5, 2.0, 3.0, 4.0, 5.0, 6.0, 8.0, 10.0}; // momentum bins
  
  Int_t pBin1 = -1;                                    // check bin1
  Int_t pBin2 = -1;                                    // check bin2

  if(p < 0) return -1;                                 // return -1 if momentum < 0
  if(p < pBins[0]) return 0;                                      // smallest momentum bin
  if(p >= pBins[10]) return 10; // largest momentum bin


  // calculate momentum bin for non extremal momenta
  for(Int_t iMomBin = 1; iMomBin < 11; iMomBin++){
    if(p < pBins[iMomBin]){
      pBin1 = iMomBin - 1;
      pBin2 = iMomBin;
    }
    else
      continue;

    if(p - pBins[pBin1] >= pBins[pBin2] - p){
      return pBin2;
    }
    else{
      return pBin1;
    }
  }

  return -1;


}

//___________________________________________________
Int_t AliHFEpidQA::GetCentrality(AliVEvent*  const fInputEvent){
  //
  // Recover the centrality of the event from ESD or AOD
  //
    Int_t bin = -1;

    if(fIsPbPb)
    {
	// Centrality
	AliCentrality *centrality = fInputEvent->GetCentrality();
	Float_t fCentralityFtemp = -1;
	fCentralityFtemp = centrality->GetCentralityPercentile("V0M");
	Float_t centralityLimits[12] = {0.,5.,10., 20., 30., 40., 50., 60.,70.,80., 90., 100.};
	for(Int_t ibin = 0; ibin < 11; ibin++){
	    if(fCentralityFtemp >= centralityLimits[ibin] && fCentralityFtemp < centralityLimits[ibin+1]){
		bin = ibin;
		break;
	    }
	}
    }
    AliDebug(2, Form("Centrality class %d\n", bin));


    return bin;
 
}

//___________________________________________________
Int_t AliHFEpidQA::GetMultiplicityITS(AliVEvent*  const fInputEvent) const
{
  //
  // Definition of the Multiplicity according to the JPSI group (F. Kramer)
  //
  Int_t nTracklets = 0;
  Int_t nAcc = 0;
  Double_t etaRange = 1.6;
  Int_t bin = -1;

  nTracklets = ((AliESDEvent*) fInputEvent)->GetMultiplicity()->GetNumberOfTracklets();
  for (Int_t nn = 0; nn < nTracklets; nn++) {
      Double_t eta = ((AliESDEvent*)fInputEvent)->GetMultiplicity()->GetEta(nn);
      if (TMath::Abs(eta) < etaRange) nAcc++;
  }

  Int_t itsMultiplicity = nAcc;

  Int_t multiplicityLimits[8] = {0, 1, 9, 17, 25, 36, 60, 500};
  for(Int_t ibin = 0; ibin < 7; ibin++){
      if(itsMultiplicity >= multiplicityLimits[ibin] && itsMultiplicity < multiplicityLimits[ibin + 1]){
	  bin = ibin;
        break;
      }
  }

  return bin;

}

 AliHFEpidQA.cxx:1
 AliHFEpidQA.cxx:2
 AliHFEpidQA.cxx:3
 AliHFEpidQA.cxx:4
 AliHFEpidQA.cxx:5
 AliHFEpidQA.cxx:6
 AliHFEpidQA.cxx:7
 AliHFEpidQA.cxx:8
 AliHFEpidQA.cxx:9
 AliHFEpidQA.cxx:10
 AliHFEpidQA.cxx:11
 AliHFEpidQA.cxx:12
 AliHFEpidQA.cxx:13
 AliHFEpidQA.cxx:14
 AliHFEpidQA.cxx:15
 AliHFEpidQA.cxx:16
 AliHFEpidQA.cxx:17
 AliHFEpidQA.cxx:18
 AliHFEpidQA.cxx:19
 AliHFEpidQA.cxx:20
 AliHFEpidQA.cxx:21
 AliHFEpidQA.cxx:22
 AliHFEpidQA.cxx:23
 AliHFEpidQA.cxx:24
 AliHFEpidQA.cxx:25
 AliHFEpidQA.cxx:26
 AliHFEpidQA.cxx:27
 AliHFEpidQA.cxx:28
 AliHFEpidQA.cxx:29
 AliHFEpidQA.cxx:30
 AliHFEpidQA.cxx:31
 AliHFEpidQA.cxx:32
 AliHFEpidQA.cxx:33
 AliHFEpidQA.cxx:34
 AliHFEpidQA.cxx:35
 AliHFEpidQA.cxx:36
 AliHFEpidQA.cxx:37
 AliHFEpidQA.cxx:38
 AliHFEpidQA.cxx:39
 AliHFEpidQA.cxx:40
 AliHFEpidQA.cxx:41
 AliHFEpidQA.cxx:42
 AliHFEpidQA.cxx:43
 AliHFEpidQA.cxx:44
 AliHFEpidQA.cxx:45
 AliHFEpidQA.cxx:46
 AliHFEpidQA.cxx:47
 AliHFEpidQA.cxx:48
 AliHFEpidQA.cxx:49
 AliHFEpidQA.cxx:50
 AliHFEpidQA.cxx:51
 AliHFEpidQA.cxx:52
 AliHFEpidQA.cxx:53
 AliHFEpidQA.cxx:54
 AliHFEpidQA.cxx:55
 AliHFEpidQA.cxx:56
 AliHFEpidQA.cxx:57
 AliHFEpidQA.cxx:58
 AliHFEpidQA.cxx:59
 AliHFEpidQA.cxx:60
 AliHFEpidQA.cxx:61
 AliHFEpidQA.cxx:62
 AliHFEpidQA.cxx:63
 AliHFEpidQA.cxx:64
 AliHFEpidQA.cxx:65
 AliHFEpidQA.cxx:66
 AliHFEpidQA.cxx:67
 AliHFEpidQA.cxx:68
 AliHFEpidQA.cxx:69
 AliHFEpidQA.cxx:70
 AliHFEpidQA.cxx:71
 AliHFEpidQA.cxx:72
 AliHFEpidQA.cxx:73
 AliHFEpidQA.cxx:74
 AliHFEpidQA.cxx:75
 AliHFEpidQA.cxx:76
 AliHFEpidQA.cxx:77
 AliHFEpidQA.cxx:78
 AliHFEpidQA.cxx:79
 AliHFEpidQA.cxx:80
 AliHFEpidQA.cxx:81
 AliHFEpidQA.cxx:82
 AliHFEpidQA.cxx:83
 AliHFEpidQA.cxx:84
 AliHFEpidQA.cxx:85
 AliHFEpidQA.cxx:86
 AliHFEpidQA.cxx:87
 AliHFEpidQA.cxx:88
 AliHFEpidQA.cxx:89
 AliHFEpidQA.cxx:90
 AliHFEpidQA.cxx:91
 AliHFEpidQA.cxx:92
 AliHFEpidQA.cxx:93
 AliHFEpidQA.cxx:94
 AliHFEpidQA.cxx:95
 AliHFEpidQA.cxx:96
 AliHFEpidQA.cxx:97
 AliHFEpidQA.cxx:98
 AliHFEpidQA.cxx:99
 AliHFEpidQA.cxx:100
 AliHFEpidQA.cxx:101
 AliHFEpidQA.cxx:102
 AliHFEpidQA.cxx:103
 AliHFEpidQA.cxx:104
 AliHFEpidQA.cxx:105
 AliHFEpidQA.cxx:106
 AliHFEpidQA.cxx:107
 AliHFEpidQA.cxx:108
 AliHFEpidQA.cxx:109
 AliHFEpidQA.cxx:110
 AliHFEpidQA.cxx:111
 AliHFEpidQA.cxx:112
 AliHFEpidQA.cxx:113
 AliHFEpidQA.cxx:114
 AliHFEpidQA.cxx:115
 AliHFEpidQA.cxx:116
 AliHFEpidQA.cxx:117
 AliHFEpidQA.cxx:118
 AliHFEpidQA.cxx:119
 AliHFEpidQA.cxx:120
 AliHFEpidQA.cxx:121
 AliHFEpidQA.cxx:122
 AliHFEpidQA.cxx:123
 AliHFEpidQA.cxx:124
 AliHFEpidQA.cxx:125
 AliHFEpidQA.cxx:126
 AliHFEpidQA.cxx:127
 AliHFEpidQA.cxx:128
 AliHFEpidQA.cxx:129
 AliHFEpidQA.cxx:130
 AliHFEpidQA.cxx:131
 AliHFEpidQA.cxx:132
 AliHFEpidQA.cxx:133
 AliHFEpidQA.cxx:134
 AliHFEpidQA.cxx:135
 AliHFEpidQA.cxx:136
 AliHFEpidQA.cxx:137
 AliHFEpidQA.cxx:138
 AliHFEpidQA.cxx:139
 AliHFEpidQA.cxx:140
 AliHFEpidQA.cxx:141
 AliHFEpidQA.cxx:142
 AliHFEpidQA.cxx:143
 AliHFEpidQA.cxx:144
 AliHFEpidQA.cxx:145
 AliHFEpidQA.cxx:146
 AliHFEpidQA.cxx:147
 AliHFEpidQA.cxx:148
 AliHFEpidQA.cxx:149
 AliHFEpidQA.cxx:150
 AliHFEpidQA.cxx:151
 AliHFEpidQA.cxx:152
 AliHFEpidQA.cxx:153
 AliHFEpidQA.cxx:154
 AliHFEpidQA.cxx:155
 AliHFEpidQA.cxx:156
 AliHFEpidQA.cxx:157
 AliHFEpidQA.cxx:158
 AliHFEpidQA.cxx:159
 AliHFEpidQA.cxx:160
 AliHFEpidQA.cxx:161
 AliHFEpidQA.cxx:162
 AliHFEpidQA.cxx:163
 AliHFEpidQA.cxx:164
 AliHFEpidQA.cxx:165
 AliHFEpidQA.cxx:166
 AliHFEpidQA.cxx:167
 AliHFEpidQA.cxx:168
 AliHFEpidQA.cxx:169
 AliHFEpidQA.cxx:170
 AliHFEpidQA.cxx:171
 AliHFEpidQA.cxx:172
 AliHFEpidQA.cxx:173
 AliHFEpidQA.cxx:174
 AliHFEpidQA.cxx:175
 AliHFEpidQA.cxx:176
 AliHFEpidQA.cxx:177
 AliHFEpidQA.cxx:178
 AliHFEpidQA.cxx:179
 AliHFEpidQA.cxx:180
 AliHFEpidQA.cxx:181
 AliHFEpidQA.cxx:182
 AliHFEpidQA.cxx:183
 AliHFEpidQA.cxx:184
 AliHFEpidQA.cxx:185
 AliHFEpidQA.cxx:186
 AliHFEpidQA.cxx:187
 AliHFEpidQA.cxx:188
 AliHFEpidQA.cxx:189
 AliHFEpidQA.cxx:190
 AliHFEpidQA.cxx:191
 AliHFEpidQA.cxx:192
 AliHFEpidQA.cxx:193
 AliHFEpidQA.cxx:194
 AliHFEpidQA.cxx:195
 AliHFEpidQA.cxx:196
 AliHFEpidQA.cxx:197
 AliHFEpidQA.cxx:198
 AliHFEpidQA.cxx:199
 AliHFEpidQA.cxx:200
 AliHFEpidQA.cxx:201
 AliHFEpidQA.cxx:202
 AliHFEpidQA.cxx:203
 AliHFEpidQA.cxx:204
 AliHFEpidQA.cxx:205
 AliHFEpidQA.cxx:206
 AliHFEpidQA.cxx:207
 AliHFEpidQA.cxx:208
 AliHFEpidQA.cxx:209
 AliHFEpidQA.cxx:210
 AliHFEpidQA.cxx:211
 AliHFEpidQA.cxx:212
 AliHFEpidQA.cxx:213
 AliHFEpidQA.cxx:214
 AliHFEpidQA.cxx:215
 AliHFEpidQA.cxx:216
 AliHFEpidQA.cxx:217
 AliHFEpidQA.cxx:218
 AliHFEpidQA.cxx:219
 AliHFEpidQA.cxx:220
 AliHFEpidQA.cxx:221
 AliHFEpidQA.cxx:222
 AliHFEpidQA.cxx:223
 AliHFEpidQA.cxx:224
 AliHFEpidQA.cxx:225
 AliHFEpidQA.cxx:226
 AliHFEpidQA.cxx:227
 AliHFEpidQA.cxx:228
 AliHFEpidQA.cxx:229
 AliHFEpidQA.cxx:230
 AliHFEpidQA.cxx:231
 AliHFEpidQA.cxx:232
 AliHFEpidQA.cxx:233
 AliHFEpidQA.cxx:234
 AliHFEpidQA.cxx:235
 AliHFEpidQA.cxx:236
 AliHFEpidQA.cxx:237
 AliHFEpidQA.cxx:238
 AliHFEpidQA.cxx:239
 AliHFEpidQA.cxx:240
 AliHFEpidQA.cxx:241
 AliHFEpidQA.cxx:242
 AliHFEpidQA.cxx:243
 AliHFEpidQA.cxx:244
 AliHFEpidQA.cxx:245
 AliHFEpidQA.cxx:246
 AliHFEpidQA.cxx:247
 AliHFEpidQA.cxx:248
 AliHFEpidQA.cxx:249
 AliHFEpidQA.cxx:250
 AliHFEpidQA.cxx:251
 AliHFEpidQA.cxx:252
 AliHFEpidQA.cxx:253
 AliHFEpidQA.cxx:254
 AliHFEpidQA.cxx:255
 AliHFEpidQA.cxx:256
 AliHFEpidQA.cxx:257
 AliHFEpidQA.cxx:258
 AliHFEpidQA.cxx:259
 AliHFEpidQA.cxx:260
 AliHFEpidQA.cxx:261
 AliHFEpidQA.cxx:262
 AliHFEpidQA.cxx:263
 AliHFEpidQA.cxx:264
 AliHFEpidQA.cxx:265
 AliHFEpidQA.cxx:266
 AliHFEpidQA.cxx:267
 AliHFEpidQA.cxx:268
 AliHFEpidQA.cxx:269
 AliHFEpidQA.cxx:270
 AliHFEpidQA.cxx:271
 AliHFEpidQA.cxx:272
 AliHFEpidQA.cxx:273
 AliHFEpidQA.cxx:274
 AliHFEpidQA.cxx:275
 AliHFEpidQA.cxx:276
 AliHFEpidQA.cxx:277
 AliHFEpidQA.cxx:278
 AliHFEpidQA.cxx:279
 AliHFEpidQA.cxx:280
 AliHFEpidQA.cxx:281
 AliHFEpidQA.cxx:282
 AliHFEpidQA.cxx:283
 AliHFEpidQA.cxx:284
 AliHFEpidQA.cxx:285
 AliHFEpidQA.cxx:286
 AliHFEpidQA.cxx:287
 AliHFEpidQA.cxx:288
 AliHFEpidQA.cxx:289
 AliHFEpidQA.cxx:290
 AliHFEpidQA.cxx:291
 AliHFEpidQA.cxx:292
 AliHFEpidQA.cxx:293
 AliHFEpidQA.cxx:294
 AliHFEpidQA.cxx:295
 AliHFEpidQA.cxx:296
 AliHFEpidQA.cxx:297
 AliHFEpidQA.cxx:298
 AliHFEpidQA.cxx:299
 AliHFEpidQA.cxx:300
 AliHFEpidQA.cxx:301
 AliHFEpidQA.cxx:302
 AliHFEpidQA.cxx:303
 AliHFEpidQA.cxx:304
 AliHFEpidQA.cxx:305
 AliHFEpidQA.cxx:306
 AliHFEpidQA.cxx:307
 AliHFEpidQA.cxx:308
 AliHFEpidQA.cxx:309
 AliHFEpidQA.cxx:310
 AliHFEpidQA.cxx:311
 AliHFEpidQA.cxx:312
 AliHFEpidQA.cxx:313
 AliHFEpidQA.cxx:314
 AliHFEpidQA.cxx:315
 AliHFEpidQA.cxx:316
 AliHFEpidQA.cxx:317
 AliHFEpidQA.cxx:318
 AliHFEpidQA.cxx:319
 AliHFEpidQA.cxx:320
 AliHFEpidQA.cxx:321
 AliHFEpidQA.cxx:322
 AliHFEpidQA.cxx:323
 AliHFEpidQA.cxx:324
 AliHFEpidQA.cxx:325
 AliHFEpidQA.cxx:326
 AliHFEpidQA.cxx:327
 AliHFEpidQA.cxx:328
 AliHFEpidQA.cxx:329
 AliHFEpidQA.cxx:330
 AliHFEpidQA.cxx:331
 AliHFEpidQA.cxx:332
 AliHFEpidQA.cxx:333
 AliHFEpidQA.cxx:334
 AliHFEpidQA.cxx:335
 AliHFEpidQA.cxx:336
 AliHFEpidQA.cxx:337
 AliHFEpidQA.cxx:338
 AliHFEpidQA.cxx:339
 AliHFEpidQA.cxx:340
 AliHFEpidQA.cxx:341
 AliHFEpidQA.cxx:342
 AliHFEpidQA.cxx:343
 AliHFEpidQA.cxx:344
 AliHFEpidQA.cxx:345
 AliHFEpidQA.cxx:346
 AliHFEpidQA.cxx:347
 AliHFEpidQA.cxx:348
 AliHFEpidQA.cxx:349
 AliHFEpidQA.cxx:350
 AliHFEpidQA.cxx:351
 AliHFEpidQA.cxx:352
 AliHFEpidQA.cxx:353
 AliHFEpidQA.cxx:354
 AliHFEpidQA.cxx:355
 AliHFEpidQA.cxx:356
 AliHFEpidQA.cxx:357
 AliHFEpidQA.cxx:358
 AliHFEpidQA.cxx:359
 AliHFEpidQA.cxx:360
 AliHFEpidQA.cxx:361
 AliHFEpidQA.cxx:362
 AliHFEpidQA.cxx:363
 AliHFEpidQA.cxx:364
 AliHFEpidQA.cxx:365
 AliHFEpidQA.cxx:366
 AliHFEpidQA.cxx:367
 AliHFEpidQA.cxx:368
 AliHFEpidQA.cxx:369
 AliHFEpidQA.cxx:370
 AliHFEpidQA.cxx:371
 AliHFEpidQA.cxx:372
 AliHFEpidQA.cxx:373
 AliHFEpidQA.cxx:374
 AliHFEpidQA.cxx:375
 AliHFEpidQA.cxx:376
 AliHFEpidQA.cxx:377
 AliHFEpidQA.cxx:378
 AliHFEpidQA.cxx:379
 AliHFEpidQA.cxx:380
 AliHFEpidQA.cxx:381
 AliHFEpidQA.cxx:382
 AliHFEpidQA.cxx:383
 AliHFEpidQA.cxx:384
 AliHFEpidQA.cxx:385
 AliHFEpidQA.cxx:386
 AliHFEpidQA.cxx:387
 AliHFEpidQA.cxx:388
 AliHFEpidQA.cxx:389
 AliHFEpidQA.cxx:390
 AliHFEpidQA.cxx:391
 AliHFEpidQA.cxx:392
 AliHFEpidQA.cxx:393
 AliHFEpidQA.cxx:394
 AliHFEpidQA.cxx:395
 AliHFEpidQA.cxx:396
 AliHFEpidQA.cxx:397
 AliHFEpidQA.cxx:398
 AliHFEpidQA.cxx:399
 AliHFEpidQA.cxx:400
 AliHFEpidQA.cxx:401
 AliHFEpidQA.cxx:402
 AliHFEpidQA.cxx:403
 AliHFEpidQA.cxx:404
 AliHFEpidQA.cxx:405
 AliHFEpidQA.cxx:406
 AliHFEpidQA.cxx:407
 AliHFEpidQA.cxx:408
 AliHFEpidQA.cxx:409
 AliHFEpidQA.cxx:410
 AliHFEpidQA.cxx:411
 AliHFEpidQA.cxx:412
 AliHFEpidQA.cxx:413
 AliHFEpidQA.cxx:414
 AliHFEpidQA.cxx:415
 AliHFEpidQA.cxx:416
 AliHFEpidQA.cxx:417
 AliHFEpidQA.cxx:418
 AliHFEpidQA.cxx:419
 AliHFEpidQA.cxx:420
 AliHFEpidQA.cxx:421
 AliHFEpidQA.cxx:422
 AliHFEpidQA.cxx:423
 AliHFEpidQA.cxx:424
 AliHFEpidQA.cxx:425
 AliHFEpidQA.cxx:426
 AliHFEpidQA.cxx:427
 AliHFEpidQA.cxx:428
 AliHFEpidQA.cxx:429
 AliHFEpidQA.cxx:430
 AliHFEpidQA.cxx:431
 AliHFEpidQA.cxx:432
 AliHFEpidQA.cxx:433
 AliHFEpidQA.cxx:434
 AliHFEpidQA.cxx:435
 AliHFEpidQA.cxx:436
 AliHFEpidQA.cxx:437
 AliHFEpidQA.cxx:438
 AliHFEpidQA.cxx:439
 AliHFEpidQA.cxx:440
 AliHFEpidQA.cxx:441
 AliHFEpidQA.cxx:442
 AliHFEpidQA.cxx:443
 AliHFEpidQA.cxx:444
 AliHFEpidQA.cxx:445
 AliHFEpidQA.cxx:446
 AliHFEpidQA.cxx:447
 AliHFEpidQA.cxx:448
 AliHFEpidQA.cxx:449
 AliHFEpidQA.cxx:450
 AliHFEpidQA.cxx:451
 AliHFEpidQA.cxx:452
 AliHFEpidQA.cxx:453
 AliHFEpidQA.cxx:454
 AliHFEpidQA.cxx:455
 AliHFEpidQA.cxx:456
 AliHFEpidQA.cxx:457
 AliHFEpidQA.cxx:458
 AliHFEpidQA.cxx:459
 AliHFEpidQA.cxx:460
 AliHFEpidQA.cxx:461
 AliHFEpidQA.cxx:462
 AliHFEpidQA.cxx:463
 AliHFEpidQA.cxx:464
 AliHFEpidQA.cxx:465
 AliHFEpidQA.cxx:466
 AliHFEpidQA.cxx:467
 AliHFEpidQA.cxx:468
 AliHFEpidQA.cxx:469
 AliHFEpidQA.cxx:470
 AliHFEpidQA.cxx:471
 AliHFEpidQA.cxx:472
 AliHFEpidQA.cxx:473
 AliHFEpidQA.cxx:474
 AliHFEpidQA.cxx:475
 AliHFEpidQA.cxx:476
 AliHFEpidQA.cxx:477
 AliHFEpidQA.cxx:478
 AliHFEpidQA.cxx:479
 AliHFEpidQA.cxx:480
 AliHFEpidQA.cxx:481
 AliHFEpidQA.cxx:482
 AliHFEpidQA.cxx:483
 AliHFEpidQA.cxx:484
 AliHFEpidQA.cxx:485
 AliHFEpidQA.cxx:486
 AliHFEpidQA.cxx:487
 AliHFEpidQA.cxx:488
 AliHFEpidQA.cxx:489
 AliHFEpidQA.cxx:490
 AliHFEpidQA.cxx:491
 AliHFEpidQA.cxx:492
 AliHFEpidQA.cxx:493
 AliHFEpidQA.cxx:494
 AliHFEpidQA.cxx:495
 AliHFEpidQA.cxx:496
 AliHFEpidQA.cxx:497
 AliHFEpidQA.cxx:498
 AliHFEpidQA.cxx:499
 AliHFEpidQA.cxx:500
 AliHFEpidQA.cxx:501
 AliHFEpidQA.cxx:502
 AliHFEpidQA.cxx:503
 AliHFEpidQA.cxx:504
 AliHFEpidQA.cxx:505
 AliHFEpidQA.cxx:506
 AliHFEpidQA.cxx:507
 AliHFEpidQA.cxx:508
 AliHFEpidQA.cxx:509
 AliHFEpidQA.cxx:510
 AliHFEpidQA.cxx:511
 AliHFEpidQA.cxx:512
 AliHFEpidQA.cxx:513
 AliHFEpidQA.cxx:514
 AliHFEpidQA.cxx:515
 AliHFEpidQA.cxx:516
 AliHFEpidQA.cxx:517
 AliHFEpidQA.cxx:518
 AliHFEpidQA.cxx:519
 AliHFEpidQA.cxx:520
 AliHFEpidQA.cxx:521
 AliHFEpidQA.cxx:522
 AliHFEpidQA.cxx:523
 AliHFEpidQA.cxx:524
 AliHFEpidQA.cxx:525
 AliHFEpidQA.cxx:526
 AliHFEpidQA.cxx:527
 AliHFEpidQA.cxx:528
 AliHFEpidQA.cxx:529
 AliHFEpidQA.cxx:530
 AliHFEpidQA.cxx:531
 AliHFEpidQA.cxx:532
 AliHFEpidQA.cxx:533
 AliHFEpidQA.cxx:534
 AliHFEpidQA.cxx:535
 AliHFEpidQA.cxx:536
 AliHFEpidQA.cxx:537
 AliHFEpidQA.cxx:538
 AliHFEpidQA.cxx:539
 AliHFEpidQA.cxx:540
 AliHFEpidQA.cxx:541
 AliHFEpidQA.cxx:542
 AliHFEpidQA.cxx:543
 AliHFEpidQA.cxx:544
 AliHFEpidQA.cxx:545
 AliHFEpidQA.cxx:546
 AliHFEpidQA.cxx:547
 AliHFEpidQA.cxx:548
 AliHFEpidQA.cxx:549
 AliHFEpidQA.cxx:550
 AliHFEpidQA.cxx:551
 AliHFEpidQA.cxx:552
 AliHFEpidQA.cxx:553
 AliHFEpidQA.cxx:554
 AliHFEpidQA.cxx:555
 AliHFEpidQA.cxx:556
 AliHFEpidQA.cxx:557
 AliHFEpidQA.cxx:558
 AliHFEpidQA.cxx:559
 AliHFEpidQA.cxx:560
 AliHFEpidQA.cxx:561
 AliHFEpidQA.cxx:562
 AliHFEpidQA.cxx:563
 AliHFEpidQA.cxx:564
 AliHFEpidQA.cxx:565
 AliHFEpidQA.cxx:566
 AliHFEpidQA.cxx:567
 AliHFEpidQA.cxx:568
 AliHFEpidQA.cxx:569
 AliHFEpidQA.cxx:570
 AliHFEpidQA.cxx:571
 AliHFEpidQA.cxx:572
 AliHFEpidQA.cxx:573
 AliHFEpidQA.cxx:574
 AliHFEpidQA.cxx:575
 AliHFEpidQA.cxx:576
 AliHFEpidQA.cxx:577
 AliHFEpidQA.cxx:578
 AliHFEpidQA.cxx:579
 AliHFEpidQA.cxx:580
 AliHFEpidQA.cxx:581
 AliHFEpidQA.cxx:582
 AliHFEpidQA.cxx:583
 AliHFEpidQA.cxx:584
 AliHFEpidQA.cxx:585
 AliHFEpidQA.cxx:586
 AliHFEpidQA.cxx:587
 AliHFEpidQA.cxx:588
 AliHFEpidQA.cxx:589
 AliHFEpidQA.cxx:590
 AliHFEpidQA.cxx:591
 AliHFEpidQA.cxx:592
 AliHFEpidQA.cxx:593
 AliHFEpidQA.cxx:594
 AliHFEpidQA.cxx:595
 AliHFEpidQA.cxx:596
 AliHFEpidQA.cxx:597
 AliHFEpidQA.cxx:598
 AliHFEpidQA.cxx:599
 AliHFEpidQA.cxx:600
 AliHFEpidQA.cxx:601
 AliHFEpidQA.cxx:602
 AliHFEpidQA.cxx:603
 AliHFEpidQA.cxx:604
 AliHFEpidQA.cxx:605
 AliHFEpidQA.cxx:606
 AliHFEpidQA.cxx:607
 AliHFEpidQA.cxx:608
 AliHFEpidQA.cxx:609
 AliHFEpidQA.cxx:610
 AliHFEpidQA.cxx:611
 AliHFEpidQA.cxx:612
 AliHFEpidQA.cxx:613
 AliHFEpidQA.cxx:614
 AliHFEpidQA.cxx:615
 AliHFEpidQA.cxx:616
 AliHFEpidQA.cxx:617
 AliHFEpidQA.cxx:618
 AliHFEpidQA.cxx:619
 AliHFEpidQA.cxx:620
 AliHFEpidQA.cxx:621
 AliHFEpidQA.cxx:622
 AliHFEpidQA.cxx:623
 AliHFEpidQA.cxx:624
 AliHFEpidQA.cxx:625
 AliHFEpidQA.cxx:626
 AliHFEpidQA.cxx:627
 AliHFEpidQA.cxx:628
 AliHFEpidQA.cxx:629
 AliHFEpidQA.cxx:630
 AliHFEpidQA.cxx:631
 AliHFEpidQA.cxx:632
 AliHFEpidQA.cxx:633
 AliHFEpidQA.cxx:634
 AliHFEpidQA.cxx:635
 AliHFEpidQA.cxx:636
 AliHFEpidQA.cxx:637
 AliHFEpidQA.cxx:638
 AliHFEpidQA.cxx:639
 AliHFEpidQA.cxx:640
 AliHFEpidQA.cxx:641
 AliHFEpidQA.cxx:642
 AliHFEpidQA.cxx:643
 AliHFEpidQA.cxx:644
 AliHFEpidQA.cxx:645
 AliHFEpidQA.cxx:646
 AliHFEpidQA.cxx:647
 AliHFEpidQA.cxx:648
 AliHFEpidQA.cxx:649
 AliHFEpidQA.cxx:650
 AliHFEpidQA.cxx:651
 AliHFEpidQA.cxx:652
 AliHFEpidQA.cxx:653
 AliHFEpidQA.cxx:654
 AliHFEpidQA.cxx:655
 AliHFEpidQA.cxx:656
 AliHFEpidQA.cxx:657
 AliHFEpidQA.cxx:658
 AliHFEpidQA.cxx:659
 AliHFEpidQA.cxx:660
 AliHFEpidQA.cxx:661
 AliHFEpidQA.cxx:662
 AliHFEpidQA.cxx:663
 AliHFEpidQA.cxx:664
 AliHFEpidQA.cxx:665
 AliHFEpidQA.cxx:666
 AliHFEpidQA.cxx:667
 AliHFEpidQA.cxx:668
 AliHFEpidQA.cxx:669
 AliHFEpidQA.cxx:670
 AliHFEpidQA.cxx:671
 AliHFEpidQA.cxx:672
 AliHFEpidQA.cxx:673
 AliHFEpidQA.cxx:674
 AliHFEpidQA.cxx:675
 AliHFEpidQA.cxx:676
 AliHFEpidQA.cxx:677
 AliHFEpidQA.cxx:678
 AliHFEpidQA.cxx:679
 AliHFEpidQA.cxx:680
 AliHFEpidQA.cxx:681
 AliHFEpidQA.cxx:682
 AliHFEpidQA.cxx:683
 AliHFEpidQA.cxx:684
 AliHFEpidQA.cxx:685
 AliHFEpidQA.cxx:686
 AliHFEpidQA.cxx:687
 AliHFEpidQA.cxx:688
 AliHFEpidQA.cxx:689
 AliHFEpidQA.cxx:690
 AliHFEpidQA.cxx:691
 AliHFEpidQA.cxx:692
 AliHFEpidQA.cxx:693
 AliHFEpidQA.cxx:694
 AliHFEpidQA.cxx:695
 AliHFEpidQA.cxx:696
 AliHFEpidQA.cxx:697
 AliHFEpidQA.cxx:698
 AliHFEpidQA.cxx:699
 AliHFEpidQA.cxx:700
 AliHFEpidQA.cxx:701
 AliHFEpidQA.cxx:702
 AliHFEpidQA.cxx:703
 AliHFEpidQA.cxx:704
 AliHFEpidQA.cxx:705
 AliHFEpidQA.cxx:706
 AliHFEpidQA.cxx:707
 AliHFEpidQA.cxx:708
 AliHFEpidQA.cxx:709
 AliHFEpidQA.cxx:710
 AliHFEpidQA.cxx:711
 AliHFEpidQA.cxx:712
 AliHFEpidQA.cxx:713
 AliHFEpidQA.cxx:714
 AliHFEpidQA.cxx:715
 AliHFEpidQA.cxx:716
 AliHFEpidQA.cxx:717
 AliHFEpidQA.cxx:718
 AliHFEpidQA.cxx:719
 AliHFEpidQA.cxx:720
 AliHFEpidQA.cxx:721
 AliHFEpidQA.cxx:722
 AliHFEpidQA.cxx:723
 AliHFEpidQA.cxx:724
 AliHFEpidQA.cxx:725
 AliHFEpidQA.cxx:726
 AliHFEpidQA.cxx:727
 AliHFEpidQA.cxx:728
 AliHFEpidQA.cxx:729
 AliHFEpidQA.cxx:730
 AliHFEpidQA.cxx:731
 AliHFEpidQA.cxx:732
 AliHFEpidQA.cxx:733
 AliHFEpidQA.cxx:734
 AliHFEpidQA.cxx:735
 AliHFEpidQA.cxx:736
 AliHFEpidQA.cxx:737
 AliHFEpidQA.cxx:738
 AliHFEpidQA.cxx:739
 AliHFEpidQA.cxx:740
 AliHFEpidQA.cxx:741
 AliHFEpidQA.cxx:742
 AliHFEpidQA.cxx:743
 AliHFEpidQA.cxx:744
 AliHFEpidQA.cxx:745
 AliHFEpidQA.cxx:746
 AliHFEpidQA.cxx:747
 AliHFEpidQA.cxx:748
 AliHFEpidQA.cxx:749
 AliHFEpidQA.cxx:750
 AliHFEpidQA.cxx:751
 AliHFEpidQA.cxx:752
 AliHFEpidQA.cxx:753
 AliHFEpidQA.cxx:754
 AliHFEpidQA.cxx:755
 AliHFEpidQA.cxx:756
 AliHFEpidQA.cxx:757
 AliHFEpidQA.cxx:758
 AliHFEpidQA.cxx:759
 AliHFEpidQA.cxx:760
 AliHFEpidQA.cxx:761
 AliHFEpidQA.cxx:762
 AliHFEpidQA.cxx:763
 AliHFEpidQA.cxx:764
 AliHFEpidQA.cxx:765
 AliHFEpidQA.cxx:766
 AliHFEpidQA.cxx:767
 AliHFEpidQA.cxx:768
 AliHFEpidQA.cxx:769
 AliHFEpidQA.cxx:770
 AliHFEpidQA.cxx:771
 AliHFEpidQA.cxx:772
 AliHFEpidQA.cxx:773
 AliHFEpidQA.cxx:774
 AliHFEpidQA.cxx:775
 AliHFEpidQA.cxx:776
 AliHFEpidQA.cxx:777
 AliHFEpidQA.cxx:778
 AliHFEpidQA.cxx:779
 AliHFEpidQA.cxx:780
 AliHFEpidQA.cxx:781
 AliHFEpidQA.cxx:782
 AliHFEpidQA.cxx:783
 AliHFEpidQA.cxx:784
 AliHFEpidQA.cxx:785
 AliHFEpidQA.cxx:786
 AliHFEpidQA.cxx:787
 AliHFEpidQA.cxx:788
 AliHFEpidQA.cxx:789
 AliHFEpidQA.cxx:790
 AliHFEpidQA.cxx:791
 AliHFEpidQA.cxx:792
 AliHFEpidQA.cxx:793
 AliHFEpidQA.cxx:794
 AliHFEpidQA.cxx:795
 AliHFEpidQA.cxx:796
 AliHFEpidQA.cxx:797
 AliHFEpidQA.cxx:798
 AliHFEpidQA.cxx:799
 AliHFEpidQA.cxx:800
 AliHFEpidQA.cxx:801
 AliHFEpidQA.cxx:802
 AliHFEpidQA.cxx:803
 AliHFEpidQA.cxx:804
 AliHFEpidQA.cxx:805
 AliHFEpidQA.cxx:806
 AliHFEpidQA.cxx:807
 AliHFEpidQA.cxx:808
 AliHFEpidQA.cxx:809
 AliHFEpidQA.cxx:810
 AliHFEpidQA.cxx:811
 AliHFEpidQA.cxx:812
 AliHFEpidQA.cxx:813
 AliHFEpidQA.cxx:814
 AliHFEpidQA.cxx:815
 AliHFEpidQA.cxx:816
 AliHFEpidQA.cxx:817
 AliHFEpidQA.cxx:818
 AliHFEpidQA.cxx:819
 AliHFEpidQA.cxx:820
 AliHFEpidQA.cxx:821
 AliHFEpidQA.cxx:822
 AliHFEpidQA.cxx:823
 AliHFEpidQA.cxx:824
 AliHFEpidQA.cxx:825
 AliHFEpidQA.cxx:826
 AliHFEpidQA.cxx:827
 AliHFEpidQA.cxx:828
 AliHFEpidQA.cxx:829
 AliHFEpidQA.cxx:830
 AliHFEpidQA.cxx:831
 AliHFEpidQA.cxx:832
 AliHFEpidQA.cxx:833
 AliHFEpidQA.cxx:834
 AliHFEpidQA.cxx:835
 AliHFEpidQA.cxx:836
 AliHFEpidQA.cxx:837
 AliHFEpidQA.cxx:838
 AliHFEpidQA.cxx:839
 AliHFEpidQA.cxx:840
 AliHFEpidQA.cxx:841
 AliHFEpidQA.cxx:842
 AliHFEpidQA.cxx:843
 AliHFEpidQA.cxx:844
 AliHFEpidQA.cxx:845
 AliHFEpidQA.cxx:846
 AliHFEpidQA.cxx:847
 AliHFEpidQA.cxx:848
 AliHFEpidQA.cxx:849
 AliHFEpidQA.cxx:850
 AliHFEpidQA.cxx:851
 AliHFEpidQA.cxx:852
 AliHFEpidQA.cxx:853
 AliHFEpidQA.cxx:854
 AliHFEpidQA.cxx:855
 AliHFEpidQA.cxx:856
 AliHFEpidQA.cxx:857
 AliHFEpidQA.cxx:858
 AliHFEpidQA.cxx:859
 AliHFEpidQA.cxx:860
 AliHFEpidQA.cxx:861
 AliHFEpidQA.cxx:862
 AliHFEpidQA.cxx:863
 AliHFEpidQA.cxx:864
 AliHFEpidQA.cxx:865
 AliHFEpidQA.cxx:866
 AliHFEpidQA.cxx:867
 AliHFEpidQA.cxx:868
 AliHFEpidQA.cxx:869
 AliHFEpidQA.cxx:870
 AliHFEpidQA.cxx:871
 AliHFEpidQA.cxx:872
 AliHFEpidQA.cxx:873
 AliHFEpidQA.cxx:874
 AliHFEpidQA.cxx:875
 AliHFEpidQA.cxx:876
 AliHFEpidQA.cxx:877
 AliHFEpidQA.cxx:878
 AliHFEpidQA.cxx:879
 AliHFEpidQA.cxx:880
 AliHFEpidQA.cxx:881
 AliHFEpidQA.cxx:882
 AliHFEpidQA.cxx:883
 AliHFEpidQA.cxx:884
 AliHFEpidQA.cxx:885
 AliHFEpidQA.cxx:886
 AliHFEpidQA.cxx:887
 AliHFEpidQA.cxx:888
 AliHFEpidQA.cxx:889
 AliHFEpidQA.cxx:890
 AliHFEpidQA.cxx:891
 AliHFEpidQA.cxx:892
 AliHFEpidQA.cxx:893
 AliHFEpidQA.cxx:894
 AliHFEpidQA.cxx:895
 AliHFEpidQA.cxx:896
 AliHFEpidQA.cxx:897
 AliHFEpidQA.cxx:898
 AliHFEpidQA.cxx:899
 AliHFEpidQA.cxx:900
 AliHFEpidQA.cxx:901
 AliHFEpidQA.cxx:902
 AliHFEpidQA.cxx:903
 AliHFEpidQA.cxx:904
 AliHFEpidQA.cxx:905
 AliHFEpidQA.cxx:906
 AliHFEpidQA.cxx:907
 AliHFEpidQA.cxx:908
 AliHFEpidQA.cxx:909
 AliHFEpidQA.cxx:910
 AliHFEpidQA.cxx:911
 AliHFEpidQA.cxx:912
 AliHFEpidQA.cxx:913
 AliHFEpidQA.cxx:914
 AliHFEpidQA.cxx:915
 AliHFEpidQA.cxx:916
 AliHFEpidQA.cxx:917
 AliHFEpidQA.cxx:918
 AliHFEpidQA.cxx:919
 AliHFEpidQA.cxx:920
 AliHFEpidQA.cxx:921
 AliHFEpidQA.cxx:922
 AliHFEpidQA.cxx:923
 AliHFEpidQA.cxx:924
 AliHFEpidQA.cxx:925
 AliHFEpidQA.cxx:926
 AliHFEpidQA.cxx:927
 AliHFEpidQA.cxx:928
 AliHFEpidQA.cxx:929
 AliHFEpidQA.cxx:930
 AliHFEpidQA.cxx:931
 AliHFEpidQA.cxx:932
 AliHFEpidQA.cxx:933
 AliHFEpidQA.cxx:934
 AliHFEpidQA.cxx:935
 AliHFEpidQA.cxx:936
 AliHFEpidQA.cxx:937
 AliHFEpidQA.cxx:938
 AliHFEpidQA.cxx:939
 AliHFEpidQA.cxx:940
 AliHFEpidQA.cxx:941
 AliHFEpidQA.cxx:942
 AliHFEpidQA.cxx:943
 AliHFEpidQA.cxx:944
 AliHFEpidQA.cxx:945
 AliHFEpidQA.cxx:946
 AliHFEpidQA.cxx:947
 AliHFEpidQA.cxx:948
 AliHFEpidQA.cxx:949
 AliHFEpidQA.cxx:950
 AliHFEpidQA.cxx:951
 AliHFEpidQA.cxx:952
 AliHFEpidQA.cxx:953
 AliHFEpidQA.cxx:954
 AliHFEpidQA.cxx:955
 AliHFEpidQA.cxx:956
 AliHFEpidQA.cxx:957
 AliHFEpidQA.cxx:958
 AliHFEpidQA.cxx:959
 AliHFEpidQA.cxx:960
 AliHFEpidQA.cxx:961
 AliHFEpidQA.cxx:962
 AliHFEpidQA.cxx:963
 AliHFEpidQA.cxx:964
 AliHFEpidQA.cxx:965
 AliHFEpidQA.cxx:966
 AliHFEpidQA.cxx:967
 AliHFEpidQA.cxx:968
 AliHFEpidQA.cxx:969
 AliHFEpidQA.cxx:970
 AliHFEpidQA.cxx:971
 AliHFEpidQA.cxx:972
 AliHFEpidQA.cxx:973
 AliHFEpidQA.cxx:974
 AliHFEpidQA.cxx:975
 AliHFEpidQA.cxx:976
 AliHFEpidQA.cxx:977
 AliHFEpidQA.cxx:978
 AliHFEpidQA.cxx:979
 AliHFEpidQA.cxx:980
 AliHFEpidQA.cxx:981
 AliHFEpidQA.cxx:982
 AliHFEpidQA.cxx:983
 AliHFEpidQA.cxx:984
 AliHFEpidQA.cxx:985
 AliHFEpidQA.cxx:986
 AliHFEpidQA.cxx:987
 AliHFEpidQA.cxx:988
 AliHFEpidQA.cxx:989
 AliHFEpidQA.cxx:990
 AliHFEpidQA.cxx:991
 AliHFEpidQA.cxx:992
 AliHFEpidQA.cxx:993
 AliHFEpidQA.cxx:994
 AliHFEpidQA.cxx:995
 AliHFEpidQA.cxx:996
 AliHFEpidQA.cxx:997
 AliHFEpidQA.cxx:998
 AliHFEpidQA.cxx:999
 AliHFEpidQA.cxx:1000
 AliHFEpidQA.cxx:1001
 AliHFEpidQA.cxx:1002
 AliHFEpidQA.cxx:1003
 AliHFEpidQA.cxx:1004
 AliHFEpidQA.cxx:1005
 AliHFEpidQA.cxx:1006
 AliHFEpidQA.cxx:1007
 AliHFEpidQA.cxx:1008
 AliHFEpidQA.cxx:1009
 AliHFEpidQA.cxx:1010
 AliHFEpidQA.cxx:1011
 AliHFEpidQA.cxx:1012
 AliHFEpidQA.cxx:1013
 AliHFEpidQA.cxx:1014
 AliHFEpidQA.cxx:1015
 AliHFEpidQA.cxx:1016
 AliHFEpidQA.cxx:1017
 AliHFEpidQA.cxx:1018
 AliHFEpidQA.cxx:1019
 AliHFEpidQA.cxx:1020
 AliHFEpidQA.cxx:1021
 AliHFEpidQA.cxx:1022
 AliHFEpidQA.cxx:1023
 AliHFEpidQA.cxx:1024
 AliHFEpidQA.cxx:1025
 AliHFEpidQA.cxx:1026
 AliHFEpidQA.cxx:1027
 AliHFEpidQA.cxx:1028
 AliHFEpidQA.cxx:1029
 AliHFEpidQA.cxx:1030
 AliHFEpidQA.cxx:1031
 AliHFEpidQA.cxx:1032
 AliHFEpidQA.cxx:1033
 AliHFEpidQA.cxx:1034
 AliHFEpidQA.cxx:1035
 AliHFEpidQA.cxx:1036
 AliHFEpidQA.cxx:1037
 AliHFEpidQA.cxx:1038
 AliHFEpidQA.cxx:1039
 AliHFEpidQA.cxx:1040
 AliHFEpidQA.cxx:1041
 AliHFEpidQA.cxx:1042
 AliHFEpidQA.cxx:1043
 AliHFEpidQA.cxx:1044
 AliHFEpidQA.cxx:1045
 AliHFEpidQA.cxx:1046
 AliHFEpidQA.cxx:1047
 AliHFEpidQA.cxx:1048
 AliHFEpidQA.cxx:1049
 AliHFEpidQA.cxx:1050
 AliHFEpidQA.cxx:1051
 AliHFEpidQA.cxx:1052
 AliHFEpidQA.cxx:1053
 AliHFEpidQA.cxx:1054
 AliHFEpidQA.cxx:1055
 AliHFEpidQA.cxx:1056
 AliHFEpidQA.cxx:1057
 AliHFEpidQA.cxx:1058
 AliHFEpidQA.cxx:1059
 AliHFEpidQA.cxx:1060
 AliHFEpidQA.cxx:1061
 AliHFEpidQA.cxx:1062
 AliHFEpidQA.cxx:1063
 AliHFEpidQA.cxx:1064
 AliHFEpidQA.cxx:1065
 AliHFEpidQA.cxx:1066
 AliHFEpidQA.cxx:1067
 AliHFEpidQA.cxx:1068
 AliHFEpidQA.cxx:1069
 AliHFEpidQA.cxx:1070
 AliHFEpidQA.cxx:1071
 AliHFEpidQA.cxx:1072
 AliHFEpidQA.cxx:1073
 AliHFEpidQA.cxx:1074
 AliHFEpidQA.cxx:1075
 AliHFEpidQA.cxx:1076
 AliHFEpidQA.cxx:1077
 AliHFEpidQA.cxx:1078
 AliHFEpidQA.cxx:1079
 AliHFEpidQA.cxx:1080
 AliHFEpidQA.cxx:1081
 AliHFEpidQA.cxx:1082
 AliHFEpidQA.cxx:1083
 AliHFEpidQA.cxx:1084
 AliHFEpidQA.cxx:1085
 AliHFEpidQA.cxx:1086
 AliHFEpidQA.cxx:1087
 AliHFEpidQA.cxx:1088
 AliHFEpidQA.cxx:1089
 AliHFEpidQA.cxx:1090
 AliHFEpidQA.cxx:1091
 AliHFEpidQA.cxx:1092
 AliHFEpidQA.cxx:1093
 AliHFEpidQA.cxx:1094
 AliHFEpidQA.cxx:1095
 AliHFEpidQA.cxx:1096
 AliHFEpidQA.cxx:1097
 AliHFEpidQA.cxx:1098
 AliHFEpidQA.cxx:1099
 AliHFEpidQA.cxx:1100
 AliHFEpidQA.cxx:1101
 AliHFEpidQA.cxx:1102
 AliHFEpidQA.cxx:1103
 AliHFEpidQA.cxx:1104
 AliHFEpidQA.cxx:1105
 AliHFEpidQA.cxx:1106
 AliHFEpidQA.cxx:1107
 AliHFEpidQA.cxx:1108
 AliHFEpidQA.cxx:1109
 AliHFEpidQA.cxx:1110
 AliHFEpidQA.cxx:1111
 AliHFEpidQA.cxx:1112
 AliHFEpidQA.cxx:1113
 AliHFEpidQA.cxx:1114
 AliHFEpidQA.cxx:1115
 AliHFEpidQA.cxx:1116
 AliHFEpidQA.cxx:1117
 AliHFEpidQA.cxx:1118
 AliHFEpidQA.cxx:1119
 AliHFEpidQA.cxx:1120
 AliHFEpidQA.cxx:1121
 AliHFEpidQA.cxx:1122
 AliHFEpidQA.cxx:1123
 AliHFEpidQA.cxx:1124
 AliHFEpidQA.cxx:1125
 AliHFEpidQA.cxx:1126
 AliHFEpidQA.cxx:1127
 AliHFEpidQA.cxx:1128
 AliHFEpidQA.cxx:1129
 AliHFEpidQA.cxx:1130
 AliHFEpidQA.cxx:1131
 AliHFEpidQA.cxx:1132
 AliHFEpidQA.cxx:1133
 AliHFEpidQA.cxx:1134
 AliHFEpidQA.cxx:1135
 AliHFEpidQA.cxx:1136
 AliHFEpidQA.cxx:1137
 AliHFEpidQA.cxx:1138
 AliHFEpidQA.cxx:1139
 AliHFEpidQA.cxx:1140
 AliHFEpidQA.cxx:1141
 AliHFEpidQA.cxx:1142
 AliHFEpidQA.cxx:1143
 AliHFEpidQA.cxx:1144
 AliHFEpidQA.cxx:1145
 AliHFEpidQA.cxx:1146
 AliHFEpidQA.cxx:1147
 AliHFEpidQA.cxx:1148
 AliHFEpidQA.cxx:1149
 AliHFEpidQA.cxx:1150
 AliHFEpidQA.cxx:1151
 AliHFEpidQA.cxx:1152
 AliHFEpidQA.cxx:1153
 AliHFEpidQA.cxx:1154
 AliHFEpidQA.cxx:1155
 AliHFEpidQA.cxx:1156
 AliHFEpidQA.cxx:1157
 AliHFEpidQA.cxx:1158
 AliHFEpidQA.cxx:1159
 AliHFEpidQA.cxx:1160
 AliHFEpidQA.cxx:1161
 AliHFEpidQA.cxx:1162
 AliHFEpidQA.cxx:1163
 AliHFEpidQA.cxx:1164
 AliHFEpidQA.cxx:1165
 AliHFEpidQA.cxx:1166
 AliHFEpidQA.cxx:1167
 AliHFEpidQA.cxx:1168
 AliHFEpidQA.cxx:1169
 AliHFEpidQA.cxx:1170
 AliHFEpidQA.cxx:1171
 AliHFEpidQA.cxx:1172
 AliHFEpidQA.cxx:1173
 AliHFEpidQA.cxx:1174
 AliHFEpidQA.cxx:1175
 AliHFEpidQA.cxx:1176
 AliHFEpidQA.cxx:1177
 AliHFEpidQA.cxx:1178
 AliHFEpidQA.cxx:1179
 AliHFEpidQA.cxx:1180
 AliHFEpidQA.cxx:1181
 AliHFEpidQA.cxx:1182
 AliHFEpidQA.cxx:1183
 AliHFEpidQA.cxx:1184
 AliHFEpidQA.cxx:1185
 AliHFEpidQA.cxx:1186
 AliHFEpidQA.cxx:1187
 AliHFEpidQA.cxx:1188
 AliHFEpidQA.cxx:1189
 AliHFEpidQA.cxx:1190
 AliHFEpidQA.cxx:1191
 AliHFEpidQA.cxx:1192
 AliHFEpidQA.cxx:1193
 AliHFEpidQA.cxx:1194
 AliHFEpidQA.cxx:1195
 AliHFEpidQA.cxx:1196
 AliHFEpidQA.cxx:1197
 AliHFEpidQA.cxx:1198
 AliHFEpidQA.cxx:1199
 AliHFEpidQA.cxx:1200
 AliHFEpidQA.cxx:1201
 AliHFEpidQA.cxx:1202
 AliHFEpidQA.cxx:1203
 AliHFEpidQA.cxx:1204
 AliHFEpidQA.cxx:1205
 AliHFEpidQA.cxx:1206
 AliHFEpidQA.cxx:1207
 AliHFEpidQA.cxx:1208
 AliHFEpidQA.cxx:1209
 AliHFEpidQA.cxx:1210
 AliHFEpidQA.cxx:1211
 AliHFEpidQA.cxx:1212
 AliHFEpidQA.cxx:1213
 AliHFEpidQA.cxx:1214
 AliHFEpidQA.cxx:1215
 AliHFEpidQA.cxx:1216
 AliHFEpidQA.cxx:1217
 AliHFEpidQA.cxx:1218
 AliHFEpidQA.cxx:1219
 AliHFEpidQA.cxx:1220
 AliHFEpidQA.cxx:1221
 AliHFEpidQA.cxx:1222
 AliHFEpidQA.cxx:1223
 AliHFEpidQA.cxx:1224
 AliHFEpidQA.cxx:1225
 AliHFEpidQA.cxx:1226
 AliHFEpidQA.cxx:1227
 AliHFEpidQA.cxx:1228
 AliHFEpidQA.cxx:1229
 AliHFEpidQA.cxx:1230
 AliHFEpidQA.cxx:1231
 AliHFEpidQA.cxx:1232
 AliHFEpidQA.cxx:1233
 AliHFEpidQA.cxx:1234
 AliHFEpidQA.cxx:1235
 AliHFEpidQA.cxx:1236
 AliHFEpidQA.cxx:1237
 AliHFEpidQA.cxx:1238
 AliHFEpidQA.cxx:1239
 AliHFEpidQA.cxx:1240
 AliHFEpidQA.cxx:1241
 AliHFEpidQA.cxx:1242
 AliHFEpidQA.cxx:1243
 AliHFEpidQA.cxx:1244
 AliHFEpidQA.cxx:1245
 AliHFEpidQA.cxx:1246
 AliHFEpidQA.cxx:1247
 AliHFEpidQA.cxx:1248
 AliHFEpidQA.cxx:1249
 AliHFEpidQA.cxx:1250
 AliHFEpidQA.cxx:1251
 AliHFEpidQA.cxx:1252
 AliHFEpidQA.cxx:1253
 AliHFEpidQA.cxx:1254
 AliHFEpidQA.cxx:1255
 AliHFEpidQA.cxx:1256
 AliHFEpidQA.cxx:1257
 AliHFEpidQA.cxx:1258
 AliHFEpidQA.cxx:1259
 AliHFEpidQA.cxx:1260
 AliHFEpidQA.cxx:1261
 AliHFEpidQA.cxx:1262
 AliHFEpidQA.cxx:1263
 AliHFEpidQA.cxx:1264
 AliHFEpidQA.cxx:1265
 AliHFEpidQA.cxx:1266
 AliHFEpidQA.cxx:1267
 AliHFEpidQA.cxx:1268
 AliHFEpidQA.cxx:1269
 AliHFEpidQA.cxx:1270
 AliHFEpidQA.cxx:1271
 AliHFEpidQA.cxx:1272
 AliHFEpidQA.cxx:1273
 AliHFEpidQA.cxx:1274
 AliHFEpidQA.cxx:1275
 AliHFEpidQA.cxx:1276
 AliHFEpidQA.cxx:1277
 AliHFEpidQA.cxx:1278
 AliHFEpidQA.cxx:1279
 AliHFEpidQA.cxx:1280
 AliHFEpidQA.cxx:1281
 AliHFEpidQA.cxx:1282
 AliHFEpidQA.cxx:1283
 AliHFEpidQA.cxx:1284
 AliHFEpidQA.cxx:1285
 AliHFEpidQA.cxx:1286
 AliHFEpidQA.cxx:1287
 AliHFEpidQA.cxx:1288
 AliHFEpidQA.cxx:1289
 AliHFEpidQA.cxx:1290
 AliHFEpidQA.cxx:1291
 AliHFEpidQA.cxx:1292
 AliHFEpidQA.cxx:1293
 AliHFEpidQA.cxx:1294
 AliHFEpidQA.cxx:1295
 AliHFEpidQA.cxx:1296
 AliHFEpidQA.cxx:1297
 AliHFEpidQA.cxx:1298
 AliHFEpidQA.cxx:1299
 AliHFEpidQA.cxx:1300
 AliHFEpidQA.cxx:1301
 AliHFEpidQA.cxx:1302
 AliHFEpidQA.cxx:1303
 AliHFEpidQA.cxx:1304
 AliHFEpidQA.cxx:1305
 AliHFEpidQA.cxx:1306
 AliHFEpidQA.cxx:1307
 AliHFEpidQA.cxx:1308
 AliHFEpidQA.cxx:1309
 AliHFEpidQA.cxx:1310
 AliHFEpidQA.cxx:1311
 AliHFEpidQA.cxx:1312
 AliHFEpidQA.cxx:1313
 AliHFEpidQA.cxx:1314
 AliHFEpidQA.cxx:1315
 AliHFEpidQA.cxx:1316
 AliHFEpidQA.cxx:1317
 AliHFEpidQA.cxx:1318
 AliHFEpidQA.cxx:1319
 AliHFEpidQA.cxx:1320
 AliHFEpidQA.cxx:1321
 AliHFEpidQA.cxx:1322
 AliHFEpidQA.cxx:1323
 AliHFEpidQA.cxx:1324
 AliHFEpidQA.cxx:1325
 AliHFEpidQA.cxx:1326
 AliHFEpidQA.cxx:1327
 AliHFEpidQA.cxx:1328
 AliHFEpidQA.cxx:1329
 AliHFEpidQA.cxx:1330
 AliHFEpidQA.cxx:1331
 AliHFEpidQA.cxx:1332
 AliHFEpidQA.cxx:1333
 AliHFEpidQA.cxx:1334
 AliHFEpidQA.cxx:1335
 AliHFEpidQA.cxx:1336
 AliHFEpidQA.cxx:1337
 AliHFEpidQA.cxx:1338
 AliHFEpidQA.cxx:1339
 AliHFEpidQA.cxx:1340
 AliHFEpidQA.cxx:1341