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.                  *
**************************************************************************/
//
// The analysis task:
// Filling an AliCFContainer with the quantities pt, eta and phi
// for tracks which survivied the particle cuts (MC resp. ESD tracks)
// Track selection is done using the AliHFE package
// 
// Author:
//  Raphaelle Bailhache <R.Bailhache@gsi.de>
//  Markus Fasel <M.Fasel@gsi.de>
//  Matus Kalisky <matus.kalisky@cern.ch>
//  MinJung Kweon <minjung@physi.uni-heidelberg.de>
//
#include <TAxis.h>
#include <TBits.h>
#include <TCanvas.h>
#include <TChain.h>
#include <TDirectory.h>
#include <TFile.h>
#include <TH3D.h>
#include <TIterator.h>
#include <TList.h>
#include <TLegend.h>
#include <TMath.h>
#include <TObjArray.h>
#include <TObjString.h>
#include <TParticle.h>
#include <TProfile.h>
#include <TString.h>
#include <TF1.h>
#include <TTree.h>

#include "AliESDtrackCuts.h"
#include "AliAnalysisManager.h"
#include "AliAnalysisUtils.h"
#include "AliAODInputHandler.h"
#include "AliAODMCParticle.h"
#include "AliAODTrack.h"
#include "AliAODVertex.h"
#include "AliCentrality.h"
#include "AliCFContainer.h"
#include "AliCFManager.h"
#include "AliESDEvent.h"
#include "AliESDInputHandler.h"
#include "AliESDtrack.h"
#include "AliLog.h"
#include "AliMCEvent.h"
#include "AliMCEventHandler.h"
#include "AliMCParticle.h"
#include "AliMultiplicity.h"
#include "AliPID.h"
#include "AliPIDResponse.h"
#include "AliOADBContainer.h"
#include "AliStack.h"
#include "AliTriggerAnalysis.h"
#include "AliTRDTriggerAnalysis.h"
#include "AliVVertex.h"

#include "AliHFEcollection.h"
#include "AliHFEcontainer.h"
#include "AliHFEcuts.h"
#include "AliHFEelecbackground.h"
#include "AliHFENonPhotonicElectron.h"
#include "AliHFEmcQA.h"
#include "AliHFEpairs.h"
#include "AliHFEpid.h"
#include "AliHFEpidQAmanager.h"
#include "AliHFEsecVtxs.h"
#include "AliHFEsecVtx.h"
#include "AliHFEsignalCuts.h"
#include "AliHFEtaggedTrackAnalysis.h"
#include "AliHFEtools.h"
#include "AliHFEV0taginfo.h"
#include "AliHFEvarManager.h"
#include "AliAnalysisTaskHFE.h"
#include "AliAODMCHeader.h"
#include "TClonesArray.h"

ClassImp(AliAnalysisTaskHFE)

//____________________________________________________________
AliAnalysisTaskHFE::AliAnalysisTaskHFE():
AliAnalysisTaskSE("PID efficiency Analysis")
  , fAODMCHeader(NULL)
  , fAODArrayMCInfo(NULL)
  , fQAlevel(0)
  , fPlugins(0)
  , fCollisionSystem(3)
  , fFillSignalOnly(kTRUE)
  , fRejectMCFakeTracks(kFALSE)
  , fFillNoCuts(kFALSE)
  , fBackGroundFactorApply(kFALSE)
  , fRemovePileUp(kFALSE)
  , fIdentifiedAsPileUp(kFALSE)
  , fIdentifiedAsOutInz(kFALSE)
  , fPassTheEventCut(kFALSE)
  , fRejectKinkMother(kFALSE)
  , fisppMultiBin(kFALSE)
  , fPbPbUserCentralityBinning(kFALSE)
  , fRemoveFirstEvent(kFALSE)
  , fisNonHFEsystematics(kFALSE)
  , fSpecialTrigger(NULL)
  , fCentralityF(-1)
  , fCentralityPercent(-1)
  , fCentralityEstimator("V0M")
  , fContributors(0.5)
  , fWeightBackGround(0.)
  , fVz(0.0)
  , fContainer(NULL)
  , fVarManager(NULL)
  , fSignalCuts(NULL)
  , fCFM(NULL)
  , fTriggerAnalysis(NULL)
  , fPID(NULL)
  , fPIDqa(NULL)
  , fTRDTriggerAnalysismb(NULL)
  , fTRDTriggerAnalysistrg(NULL)
  , fPIDpreselect(NULL)
  , fCuts(NULL)
  , fTaggedTrackCuts(NULL)
  , fCleanTaggedTrack(kFALSE)
  , fVariablesTRDTaggedTrack(kFALSE)
  , fAnalysisUtils(NULL)
  , fCutspreselect(NULL)
  , fSecVtx(NULL)
  , fElecBackGround(NULL)
  , fMCQA(NULL)
  , fTaggedTrackAnalysis(NULL)
  , fExtraCuts(NULL)
  , fBackgroundSubtraction(NULL)
  , fTRDTrigger(kFALSE)
  , fWhichTRDTrigger(0)
  , fV0Tagger(NULL)
  , fQA(NULL)
  , fOutput(NULL)
  , fHistMCQA(NULL)
  , fHistSECVTX(NULL)
  , fHistELECBACKGROUND(NULL)
  , fQACollection(NULL)
{
  //
  // Dummy constructor
  //
  memset(fElecBackgroundFactor, 0, sizeof(Double_t) * kElecBgSpecies * kBgPtBins * kCentBins * kBgLevels);
  memset(fkBackGroundFactorArray, 0, sizeof(TF1 *) * 12);
  memset(fBinLimit, 0, sizeof(Double_t) * (kBgPtBins+1));
  memset(&fisppMultiBin, kFALSE, sizeof(fisppMultiBin));
  memset(fCentralityLimits, 0, sizeof(Float_t) * 12);

  SetppAnalysis();
}

//____________________________________________________________
AliAnalysisTaskHFE::AliAnalysisTaskHFE(const char * name):
  AliAnalysisTaskSE(name)
  , fAODMCHeader(NULL)
  , fAODArrayMCInfo(NULL)
  , fQAlevel(0)
  , fPlugins(0)
  , fCollisionSystem(3)
  , fFillSignalOnly(kTRUE)
  , fRejectMCFakeTracks(kFALSE)
  , fFillNoCuts(kFALSE)
  , fBackGroundFactorApply(kFALSE)
  , fRemovePileUp(kFALSE)
  , fIdentifiedAsPileUp(kFALSE)
  , fIdentifiedAsOutInz(kFALSE)
  , fPassTheEventCut(kFALSE)  
  , fRejectKinkMother(kFALSE)
  , fisppMultiBin(kFALSE)
  , fPbPbUserCentralityBinning(kFALSE)
  , fRemoveFirstEvent(kFALSE)
  , fisNonHFEsystematics(kFALSE)
  , fSpecialTrigger(NULL)
  , fCentralityF(-1)
  , fCentralityPercent(-1)
  , fCentralityEstimator("V0M")
  , fContributors(0.5)
  , fWeightBackGround(0.)
  , fVz(0.0)
  , fContainer(NULL)
  , fVarManager(NULL)
  , fSignalCuts(NULL)
  , fCFM(NULL)
  , fTriggerAnalysis(NULL)
  , fPID(NULL)
  , fPIDqa(NULL)
  , fTRDTriggerAnalysismb(NULL)
  , fTRDTriggerAnalysistrg(NULL)
  , fPIDpreselect(NULL)
  , fCuts(NULL)
  , fTaggedTrackCuts(NULL)
  , fCleanTaggedTrack(kFALSE)
  , fVariablesTRDTaggedTrack(kFALSE)
  , fAnalysisUtils(NULL)
  , fCutspreselect(NULL)
  , fSecVtx(NULL)
  , fElecBackGround(NULL)
  , fMCQA(NULL)
  , fTaggedTrackAnalysis(NULL)
  , fExtraCuts(NULL)
  , fBackgroundSubtraction(NULL)
  , fTRDTrigger(kFALSE)
  , fWhichTRDTrigger(0)
  , fV0Tagger(NULL)
  , fQA(NULL)
  , fOutput(NULL)
  , fHistMCQA(NULL)
  , fHistSECVTX(NULL)
  , fHistELECBACKGROUND(NULL)
  , fQACollection(0x0)
{
  //
  // Default constructor
  // 
  DefineOutput(1, TList::Class());
  DefineOutput(2, TList::Class());

  fV0Tagger = new AliHFEV0taginfo("Tagger");
  fPID = new AliHFEpid("hfePid");
  fPIDqa = new AliHFEpidQAmanager;
  fVarManager = new AliHFEvarManager("hfeVarManager");
  fAnalysisUtils = new AliAnalysisUtils;
  fTRDTriggerAnalysismb = new AliTRDTriggerAnalysis();
  fTRDTriggerAnalysistrg = new AliTRDTriggerAnalysis();
  fTRDTriggerAnalysistrg->SetRequireMatchElectron(kTRUE);

  memset(fElecBackgroundFactor, 0, sizeof(Double_t) * kElecBgSpecies * kBgPtBins * kCentBins * kBgLevels);
  memset(fkBackGroundFactorArray, 0, sizeof(TF1 *) * 12);
  memset(fBinLimit, 0, sizeof(Double_t) * (kBgPtBins+1));
  memset(&fisppMultiBin, kFALSE, sizeof(fisppMultiBin));
  memset(fCentralityLimits, 0, sizeof(Float_t) * 12);

  SetppAnalysis();
}

//____________________________________________________________
AliAnalysisTaskHFE::AliAnalysisTaskHFE(const AliAnalysisTaskHFE &ref):
  AliAnalysisTaskSE(ref)
  , fAODMCHeader(NULL)
  , fAODArrayMCInfo(NULL)
  , fQAlevel(0)
  , fPlugins(0)
  , fCollisionSystem(ref.fCollisionSystem)
  , fFillSignalOnly(ref.fFillSignalOnly)
  , fRejectMCFakeTracks(ref.fRejectMCFakeTracks)
  , fFillNoCuts(ref.fFillNoCuts)
  , fBackGroundFactorApply(ref.fBackGroundFactorApply)
  , fRemovePileUp(ref.fRemovePileUp)
  , fIdentifiedAsPileUp(ref.fIdentifiedAsPileUp)
  , fIdentifiedAsOutInz(ref.fIdentifiedAsOutInz)
  , fPassTheEventCut(ref.fPassTheEventCut)
  , fRejectKinkMother(ref.fRejectKinkMother)
  , fisppMultiBin(ref.fisppMultiBin)
  , fPbPbUserCentralityBinning(ref.fPbPbUserCentralityBinning)
  , fRemoveFirstEvent(ref.fRemoveFirstEvent)
  , fisNonHFEsystematics(ref.fisNonHFEsystematics)
  , fSpecialTrigger(ref.fSpecialTrigger)
  , fCentralityF(ref.fCentralityF)
  , fCentralityPercent(ref.fCentralityPercent)
  , fCentralityEstimator(ref.fCentralityEstimator)
  , fContributors(ref.fContributors)
  , fWeightBackGround(ref.fWeightBackGround)
  , fVz(ref.fVz)
  , fContainer(NULL)
  , fVarManager(NULL)
  , fSignalCuts(NULL)
  , fCFM(NULL)
  , fTriggerAnalysis(NULL)
  , fPID(NULL)
  , fPIDqa(NULL)
  , fTRDTriggerAnalysismb(NULL)
  , fTRDTriggerAnalysistrg(NULL)
  , fPIDpreselect(NULL)
  , fCuts(NULL)
  , fTaggedTrackCuts(NULL)
  , fCleanTaggedTrack(ref.fCleanTaggedTrack)
  , fVariablesTRDTaggedTrack(ref.fVariablesTRDTaggedTrack)
  , fAnalysisUtils(NULL)
  , fCutspreselect(NULL)
  , fSecVtx(NULL)
  , fElecBackGround(NULL)
  , fMCQA(NULL)
  , fTaggedTrackAnalysis(NULL)
  , fExtraCuts(NULL)
  , fBackgroundSubtraction(NULL)
  , fTRDTrigger(ref.fTRDTrigger)
  , fWhichTRDTrigger(ref.fWhichTRDTrigger)
  , fV0Tagger(NULL)
  , fQA(NULL)
  , fOutput(NULL)
  , fHistMCQA(NULL)
  , fHistSECVTX(NULL)
  , fHistELECBACKGROUND(NULL)
  , fQACollection(NULL)
{
  //
  // Copy Constructor
  //
  ref.Copy(*this);
}

//____________________________________________________________
AliAnalysisTaskHFE &AliAnalysisTaskHFE::operator=(const AliAnalysisTaskHFE &ref){
  //
  // Assignment operator
  //
  if(this == &ref) 
    ref.Copy(*this);
  return *this;
}

//____________________________________________________________
void AliAnalysisTaskHFE::Copy(TObject &o) const {
  // 
  // Copy into object o
  //
  AliAnalysisTaskHFE &target = dynamic_cast<AliAnalysisTaskHFE &>(o);
  target.fAODMCHeader = fAODMCHeader;
  target.fAODArrayMCInfo = fAODArrayMCInfo;
  target.fQAlevel = fQAlevel;
  target.fPlugins = fPlugins;
  target.fCollisionSystem = fCollisionSystem;
  target.fFillSignalOnly = fFillSignalOnly;
  target.fRejectMCFakeTracks = fRejectMCFakeTracks;
  target.fFillNoCuts = fFillNoCuts;
  target.fBackGroundFactorApply = fBackGroundFactorApply;
  target.fRemovePileUp = fRemovePileUp;
  target.fIdentifiedAsPileUp = fIdentifiedAsPileUp;
  target.fIdentifiedAsOutInz = fIdentifiedAsOutInz;
  target.fPassTheEventCut = fPassTheEventCut;
  target.fRejectKinkMother = fRejectKinkMother;
  target.fisppMultiBin =   fisppMultiBin;
  target.fPbPbUserCentralityBinning = fPbPbUserCentralityBinning;
  target.fRemoveFirstEvent = fRemoveFirstEvent;
  target.fisNonHFEsystematics = fisNonHFEsystematics;
  target.fSpecialTrigger = fSpecialTrigger;
  target.fCentralityF = fCentralityF;
  target.fCentralityPercent = fCentralityPercent;
  target.fCentralityEstimator = fCentralityEstimator;
  target.fContributors = fContributors;
  target.fWeightBackGround = fWeightBackGround;
  target.fVz = fVz;
  target.fContainer = fContainer;
  target.fVarManager = fVarManager;
  target.fSignalCuts = fSignalCuts;
  target.fCFM = fCFM;
  target.fTriggerAnalysis = fTriggerAnalysis;
  target.fPID = fPID;
  target.fPIDqa = fPIDqa;
  target.fTRDTriggerAnalysismb = fTRDTriggerAnalysismb;
  target.fTRDTriggerAnalysistrg = fTRDTriggerAnalysistrg;
  target.fPIDpreselect = fPIDpreselect;
  target.fCuts = fCuts;
  target.fTaggedTrackCuts = fTaggedTrackCuts;
  target.fCleanTaggedTrack = fCleanTaggedTrack;
  target.fVariablesTRDTaggedTrack = fVariablesTRDTaggedTrack;
  target.fAnalysisUtils = fAnalysisUtils;
  target.fCutspreselect = fCutspreselect;
  target.fSecVtx = fSecVtx;
  target.fElecBackGround = fElecBackGround;
  target.fMCQA = fMCQA;
  target.fTaggedTrackAnalysis = fTaggedTrackAnalysis;
  target.fExtraCuts = fExtraCuts;
  target.fBackgroundSubtraction = fBackgroundSubtraction;
  target.fTRDTrigger = fTRDTrigger;
  target.fWhichTRDTrigger = fWhichTRDTrigger;
  target.fV0Tagger = fV0Tagger;
  target.fQA = fQA;
  target.fOutput = fOutput;
  target.fHistMCQA = fHistMCQA;
  target.fHistSECVTX = fHistSECVTX;
  target.fHistELECBACKGROUND = fHistELECBACKGROUND;
  target.fQACollection = fQACollection;
}

//____________________________________________________________
AliAnalysisTaskHFE::~AliAnalysisTaskHFE(){
  //
  // Destructor
  //
  if(fPID) delete fPID;
  if(fPIDpreselect) delete fPIDpreselect;
  if(fVarManager) delete fVarManager;
  if(fTRDTriggerAnalysismb) delete fTRDTriggerAnalysismb;
  if(fTRDTriggerAnalysistrg) delete fTRDTriggerAnalysistrg;
  if(fCFM) delete fCFM;
  if(fTriggerAnalysis) delete fTriggerAnalysis;
  if(fSignalCuts) delete fSignalCuts;
  if(fSecVtx) delete fSecVtx;
  if(fMCQA) delete fMCQA;
  if(fElecBackGround) delete fElecBackGround;
  if(fBackgroundSubtraction) delete fBackgroundSubtraction;
  if(fSpecialTrigger) delete fSpecialTrigger;
  if(fAnalysisUtils) delete fAnalysisUtils;
  if(fV0Tagger) delete fV0Tagger;
  // Delete output objects only if we are not running in PROOF mode because otherwise this produces a crash during merging
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if(mgr && mgr->GetAnalysisType() != AliAnalysisManager::kProofAnalysis){
    if(fPIDqa) delete fPIDqa;
    if(fOutput) delete fOutput;
    if(fQA) delete fQA;
  }
}

//____________________________________________________________
void AliAnalysisTaskHFE::UserCreateOutputObjects(){
  //
  // Creating output container and output objects
  // Here we also Initialize the correction framework container and 
  // the objects for
  // - PID
  // - MC QA
  // - SecVtx
  // QA histograms are created if requested
  // Called once per worker
  //
  AliDebug(3, "Creating Output Objects");
  
  // Make lists for Output
  if(!fQA) fQA = new TList;
  fQA->SetOwner();
  if(!fOutput) fOutput = new TList;
  fOutput->SetOwner();
  
  // Automatic determination of the analysis mode
  AliVEventHandler *inputHandler = dynamic_cast<AliVEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
  if(!TString(inputHandler->IsA()->GetName()).CompareTo("AliAODInputHandler")){
    SetAODAnalysis();
  } else {
    SetESDAnalysis();
    if(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler())
      SetHasMCData();
  }
  printf("Analysis Mode: %s Analysis\n", IsAODanalysis() ? "AOD" : "ESD");
  printf("MC Data available %s\n", HasMCData() ? "Yes" : "No");

  // Enable Trigger Analysis
  fTriggerAnalysis = new AliTriggerAnalysis;
  fTriggerAnalysis->EnableHistograms();
  fTriggerAnalysis->SetAnalyzeMC(HasMCData());

  // First Part: Make QA histograms
  fQACollection = new AliHFEcollection("TaskQA", "QA histos from the Electron Task");
  fQACollection->CreateTH1F("nElectronTracksEvent", "Number of Electron Candidates", 100, 0, 100);
  fQACollection->CreateTH1F("nElectron", "Number of electrons", 100, 0, 100);
  fQACollection->CreateTH2F("radius", "Production Vertex", 100, 0.0, 5.0, 100, 0.0, 5.0);
  fQACollection->CreateTH1F("nTriggerBit", "Histo Trigger Bit", 22, 0, 22);
  fQACollection->CreateTH2F("TriggerAnalysis","TRD Trigger Analysis",10,0.,10.,10,0.,10.);
  fQACollection->CreateTH1F("Filterbegin", "AOD filter of tracks after all cuts", 21, -1, 20);
  fQACollection->CreateTH1F("Filterend", "AOD filter of tracks after all cuts", 21, -1, 20);
  fQACollection->CreateTH2F("Kinkbefore", "Kink status before filter; p_{T} (GeV/c); kink status", 100, 0., 20., 3, -0.5, 2.5);
  fQACollection->CreateTH2F("Kinkafter", "Kink status after filter; p_{T} (GeV/c); kink status", 100, 0., 20., 3, -0.5, 2.5);
  fQACollection->CreateTH1F("HFPuzzle", "Source definition for electrons from HF", 11, -0.5, 10.5);
  InitHistoRadius();
  InitHistoITScluster();
  InitContaminationQA();
  fQA->Add(fQACollection);

  // Initialize PID
  fPID->SetHasMCData(HasMCData());
  if(!fPID->GetNumberOfPIDdetectors()) fPID->AddDetector("TPC", 0);
  if(IsQAOn(kPIDqa)){
    AliInfo("PID QA switched on");
    fPIDqa->Initialize(fPID);
    fQA->Add(fPIDqa->MakeList("HFEpidQA"));
  }
  fPID->SortDetectors();

  // Background subtraction-------------------------------------------------------------------
  if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) {
    if(!fBackgroundSubtraction) fBackgroundSubtraction = new AliHFENonPhotonicElectron();
    if(IsAODanalysis()) fBackgroundSubtraction->SetAOD(kTRUE);
    fBackgroundSubtraction->Init();
    fOutput->Add(fBackgroundSubtraction->GetListOutput());
  }
  //------------------------------------------------------------------------------------------


  // Initialize correction Framework and Cuts
  const Int_t kNcutSteps = AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack + AliHFEcuts::kNcutStepsDETrack + AliHFEcuts::kNcutStepsSecvtxTrack;
  fCFM = new AliCFManager;
  fCFM->SetNStepParticle(kNcutSteps);
  MakeParticleContainer();
  MakeEventContainer();
  // Temporary fix: Initialize particle cuts with NULL
  for(Int_t istep = 0; istep < kNcutSteps; istep++)
    fCFM->SetParticleCutsList(istep, NULL);
  if(!fCuts){
    AliWarning("Cuts not available. Default cuts will be used");
    fCuts = new AliHFEcuts;
    fCuts->CreateStandardCuts();
  }
  if(IsAODanalysis()) fCuts->SetAOD();
  // Make clone for V0 tagging step
  fCuts->Initialize(fCFM);
  if(fCuts->IsQAOn()) fQA->Add(fCuts->GetQAhistograms());
  fSignalCuts = new AliHFEsignalCuts("HFEsignalCuts", "HFE MC Signal definition");
  fVarManager->SetSignalCuts(fSignalCuts);
 
  // add output objects to the List
  fOutput->AddAt(fContainer, 0);
  fOutput->AddAt(fCFM->GetEventContainer(), 1);
  
  // mcQA----------------------------------
  if (HasMCData() && IsQAOn(kMCqa)) {
    AliInfo("MC QA on");
    if(!fMCQA) fMCQA = new AliHFEmcQA;
    if(!fHistMCQA) fHistMCQA = new TList();
    fHistMCQA->SetOwner();
    if(IsPbPb()) fMCQA->SetPbPb();
    if(fisppMultiBin) fMCQA->SetPPMultiBin();
    if(TestBit(kTreeStream)){
      fMCQA->EnableDebugStreamer();
    }
    if(TestBit(kWeightHist)){
      fMCQA->EnableGetWeightHist();
    }
    fMCQA->CreatDefaultHistograms(fHistMCQA);
    fMCQA->SetBackgroundWeightFactor(fElecBackgroundFactor[0][0][0],fBinLimit);
    fQA->Add(fHistMCQA);
  } 

  // secvtx----------------------------------
  if (GetPlugin(kSecVtx)) {
    AliInfo("Secondary Vertex Analysis on");
    if(!fSecVtx) fSecVtx = new AliHFEsecVtx;
    fSecVtx->SetHasMCData(HasMCData());

    if(!fHistSECVTX) fHistSECVTX = new TList();
    fHistSECVTX->SetOwner();
    fSecVtx->CreateHistograms(fHistSECVTX);
    fOutput->Add(fHistSECVTX);
  }

  // background----------------------------------
  if (GetPlugin(kIsElecBackGround)) {
    AliInfo("Electron BackGround Analysis on");
    if(!fElecBackGround){
      AliWarning("ElecBackGround not available. Default elecbackground will be used");
      fElecBackGround = new AliHFEelecbackground;
    }
    fElecBackGround->SetHasMCData(HasMCData());

    if(!fHistELECBACKGROUND) fHistELECBACKGROUND = new TList();
    fHistELECBACKGROUND->SetOwner();
    fElecBackGround->CreateHistograms(fHistELECBACKGROUND);
    fOutput->Add(fHistELECBACKGROUND);
  }  

  // tagged tracks
  if(GetPlugin(kTaggedTrackAnalysis)){
    AliInfo("Analysis on V0-tagged tracks enabled");
    fTaggedTrackAnalysis = new AliHFEtaggedTrackAnalysis(Form("taggedTrackAnalysis%s", GetName()));
    fTaggedTrackAnalysis->SetCuts(fTaggedTrackCuts);
    fTaggedTrackAnalysis->SetClean(fCleanTaggedTrack);
    if(IsAODanalysis()) fTaggedTrackAnalysis->SetAOD();
    AliHFEvarManager *varManager = fTaggedTrackAnalysis->GetVarManager();
    TObjArray *array = fVarManager->GetVariables();
    Int_t nvars = array->GetEntriesFast();
    TString namee;
    for(Int_t v = 0; v < nvars; v++) {
      AliHFEvarManager::AliHFEvariable *variable = (AliHFEvarManager::AliHFEvariable *) array->At(v);
      if(!variable) continue;
      TString name(((AliHFEvarManager::AliHFEvariable *)variable)->GetName());
      if(!name.CompareTo("source")) namee = TString("species");
      else namee = TString(name);
      Int_t nbins = variable->GetNumberOfBins();
      if(variable->HasUserDefinedBinning()){
        varManager->AddVariable(namee, nbins, variable->GetBinning());
      } else {
        varManager->AddVariable(namee, nbins, variable->GetMinimum(), variable->GetMaximum());
      }
      //printf("For AliTaggedTrackAnalysis, had the variable %s and the one used %s\n",(const char*)variable->GetName(),(const char*) namee);
    }
    if(fPIDqa->HasHighResolutionHistos()) 
      fTaggedTrackAnalysis->GetPIDqa()->SetHighResolutionHistos();
    fTaggedTrackAnalysis->SetPID(fPID);
    fTaggedTrackAnalysis->SetVariablesTRD(fVariablesTRDTaggedTrack);
    fTaggedTrackAnalysis->InitContainer();
    fOutput->Add(fTaggedTrackAnalysis->GetContainer());
    fQA->Add(fTaggedTrackAnalysis->GetPIDQA());
    fQA->Add(fTaggedTrackAnalysis->GetCutQA());
    fQA->Add(fTaggedTrackAnalysis->GetQAcollection());
  }

  //fQA->Print();

  PrintStatus();
  // Done!!!
  PostData(1, fOutput);
  PostData(2, fQA);
}

//____________________________________________________________
void AliAnalysisTaskHFE::UserExec(Option_t *){
  //
  // Run the analysis
  // 

  //printf("test00\n");

  AliDebug(3, "Starting Single Event Analysis");
  if(!fInputEvent){
    AliError("Reconstructed Event not available");
    //printf("Reconstructed Event not available");
    return;
  }
  if(HasMCData() && IsESDanalysis()){
    AliDebug(4, Form("MC Event: %p", fMCEvent));
    if(!fMCEvent){
      AliError("No MC Event, but MC Data required");
      //printf("No MC Event, but MC Data required");
      return;
    }
  }
  if(!fCuts){
    AliError("HFE cuts not available");
    //printf("HFE cuts not available");
    return;
  }
  if(!fPID->IsInitialized()){
    // Initialize PID with the given run number
    fPID->InitializePID(fInputEvent->GetRunNumber());
  }

  if(fRemoveFirstEvent){
    if(fAnalysisUtils->IsFirstEventInChunk(fInputEvent)) return;
  }

  AliESDEvent *ev = dynamic_cast<AliESDEvent *>(fInputEvent);
  if(ev && fTRDTrigger && (fWhichTRDTrigger<6))
  {
      if(!CheckTRDTriggerESD(ev)) return;
  }
  if(fInputEvent && fTRDTrigger && (fWhichTRDTrigger>5))
  {
      if(!CheckTRDTrigger(fInputEvent)) return;
  }

  if(IsESDanalysis() && HasMCData()){
    // Protect against missing MC trees
    AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
    if(!mcH){ 
      AliError("No MC Event Handler available");
      return;
    }
    if(!mcH->InitOk()) return;
    if(!mcH->TreeK()) return;
    if(!mcH->TreeTR()) return;

    // Background subtraction-------------------------------------------------------------------
    if(GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->SetMCEvent(fMCEvent);
    //------------------------------------------------------------------------------------------
  }

  if(IsAODanalysis() && HasMCData()){
    // take MC info
    AliAODEvent *aodE = dynamic_cast<AliAODEvent *>(fInputEvent);
    if(!aodE){ 
      AliError("No AOD Event");
      return;
    }
    fAODMCHeader = dynamic_cast<AliAODMCHeader *>(fInputEvent->FindListObject(AliAODMCHeader::StdBranchName()));
    if(!fAODMCHeader){ 
      AliError("No AliAODMCHeader");
      //printf("No AliAODMCHeader");
      return;
    }
    fAODArrayMCInfo = dynamic_cast<TClonesArray *>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
    if(!fAODArrayMCInfo){ 
      AliError("No AOD MC particles");
      //printf("No AOD MC particles");
      return;
    }
    fSignalCuts->SetMCAODInfo(fAODArrayMCInfo);
    // Background subtraction-------------------------------------------------------------------
    if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->SetAODArrayMCInfo(fAODArrayMCInfo);
    //------------------------------------------------------------------------------------------
  }

  //printf("test2\n");

  // need the centrality for everything (MC also)
  fCentralityF = -1;
  if(!ReadCentrality()) fCentralityF = -1;
  //printf("pass centrality\n");
  //printf("Reading fCentralityF %d\n",fCentralityF);
  
  // See if pile up and z in the range
  RejectionPileUpVertexRangeEventCut();

  //printf("test3\n");

  // Protect agains missing 
  if(HasMCData()){
    //printf("Has MC data\n");
    fSignalCuts->SetMCEvent(fMCEvent);
    ProcessMC();  // Run the MC loop + MC QA in case MC Data are available
  }
  
  AliPIDResponse *pidResponse = fInputHandler->GetPIDResponse();
  if(!pidResponse){
    AliDebug(1, "Using default PID Response");
    pidResponse = AliHFEtools::GetDefaultPID(HasMCData(), fInputEvent->IsA() == AliESDEvent::Class());
  }
  fPID->SetPIDResponse(pidResponse);
  if(fPIDpreselect) fPIDpreselect->SetPIDResponse(pidResponse);

  // Background subtraction-------------------------------------------------------------------
  if(GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->InitRun(fInputEvent,pidResponse);
  //------------------------------------------------------------------------------------------

  // Event loop
  if(IsAODanalysis()){
    //printf("test4\n");
    ProcessAOD();
  } else {
    const char *specialTrigger = GetSpecialTrigger(fInputEvent->GetRunNumber());
    // Check Trigger selection
    if(specialTrigger){
      AliDebug(2, Form("Special Trigger requested: %s", specialTrigger));
      if(!(ev && ev->IsTriggerClassFired(specialTrigger))){
        AliDebug(2, "Event not selected"); 
        return;
      } else AliDebug(2, "Event Selected");
    } else AliDebug(2, "No Special Trigger requested");
    
    ProcessESD();
  }
  // Done!!!
  PostData(1, fOutput);
  PostData(2, fQA);
}

//____________________________________________________________
void AliAnalysisTaskHFE::Terminate(Option_t *){
  //
  // Terminate not implemented at the moment
  //
}

//_______________________________________________________________
Bool_t AliAnalysisTaskHFE::IsEventInBinZero() {
  //
  //
  //

  //printf("test in IsEventInBinZero\n");
  if(!fInputEvent){
    AliError("Reconstructed Event not available");
    return kFALSE;
  }

  // check vertex
  const AliVVertex *vertex = fInputEvent->GetPrimaryVertex();
  if(!vertex) return kTRUE;
  //if(vertex) return kTRUE;

  // check tracks
  if(fInputEvent->GetNumberOfTracks()<=0) return kTRUE;
  //if(fInputEvent->GetNumberOfTracks()>0) return kTRUE;
  
  
  return kFALSE;
  
}
//____________________________________________________________
void AliAnalysisTaskHFE::ProcessMC(){
  //
  // Runs the MC Loop (filling the container for the MC Cut Steps with the observables pt, eta and phi)
  // In case MC QA is on also MC QA loop is done
  //
  AliDebug(3, "Processing MC Information");
  Double_t eventContainer [4] = {0., 0., 0., 0.};
  if(IsESDanalysis()) eventContainer[0] = fMCEvent->GetPrimaryVertex()->GetZ();
  else eventContainer[0] = fAODMCHeader->GetVtxZ();
  eventContainer[2] = fCentralityF;
  eventContainer[3] = fContributors;
  fVz = eventContainer[0];
  //printf("z position is %f\n",eventContainer[0]);
  //if(fCFM->CheckEventCuts(AliHFEcuts::kEventStepGenerated, fMCEvent)) 
  fCFM->GetEventContainer()->Fill(eventContainer,AliHFEcuts::kEventStepGenerated);
  Int_t nElectrons = 0;
  if(IsESDanalysis()){
   if(!((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0))){ //kStepMCGeneratedZOutNoPileUpCentralityFine
    if (HasMCData() && IsQAOn(kMCqa)) {
      AliDebug(2, "Running MC QA");

      if(fMCEvent->Stack()){
        fMCQA->SetMCEvent(fMCEvent);
        fMCQA->SetGenEventHeader(fMCEvent->GenEventHeader());
        fMCQA->SetCentrality(fCentralityF);
        fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));
        if(IsPbPb()) { fMCQA->SetPbPb();}
        else
        {
            if(fisppMultiBin) fMCQA->SetPPMultiBin();
            else fMCQA->SetPP();
        }
        fMCQA->Init();

        fMCQA->GetMesonKine();

        // loop over all tracks for decayed electrons
        for (Int_t igen = 0; igen < fMCEvent->GetNumberOfTracks(); igen++){
          TParticle* mcpart = fMCEvent->Stack()->Particle(igen);
          if(!mcpart) continue;
          fMCQA->GetQuarkKine(mcpart, igen, AliHFEmcQA::kCharm);
          fMCQA->GetQuarkKine(mcpart, igen, AliHFEmcQA::kBeauty);
          fMCQA->GetHadronKine(mcpart, AliHFEmcQA::kCharm);
          fMCQA->GetHadronKine(mcpart, AliHFEmcQA::kBeauty);
          fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kCharm,  AliHFEmcQA::kElectronPDG); // no accept cut
          fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kBeauty, AliHFEmcQA::kElectronPDG); // no accept cut
          fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kOthers, AliHFEmcQA::kElectronPDG); // no accept cut
        }
        //fMCQA->EndOfEventAna(AliHFEmcQA::kCharm);
        //fMCQA->EndOfEventAna(AliHFEmcQA::kBeauty);
      }

    } // end of MC QA loop
   }
   // -----------------------------------------------------------------
   fCFM->SetMCEventInfo(fMCEvent);
   // fCFM->CheckEventCuts(AliCFManager::kEvtRecCuts, fESD);
  } else {
    fMCQA->SetMCArray(fAODArrayMCInfo);

    if(!((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0))){ //kStepMCGeneratedZOutNoPileUpCentralityFine
      if (HasMCData() && IsQAOn(kMCqa)) {
        AliDebug(2, "Running MC QA");

        fMCQA->SetCentrality(fCentralityF);
        fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));

        if(IsPbPb()) { fMCQA->SetPbPb();}
        else
        {
            if(fisppMultiBin) fMCQA->SetPPMultiBin();
            else fMCQA->SetPP();
        }
        fMCQA->Init();

        //fMCQA->GetMesonKine();

        // loop over all tracks for decayed electrons
        AliAODMCParticle * mcpart;
        for (Int_t igen = 0; igen < fAODArrayMCInfo->GetEntriesFast(); igen++){
          mcpart = dynamic_cast<AliAODMCParticle *>(fAODArrayMCInfo->At(igen));
          if(!mcpart) continue;
          fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kCharm,  AliHFEmcQA::kElectronPDG); // no accept cut
          fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kBeauty, AliHFEmcQA::kElectronPDG); // no accept cut
          fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kOthers, AliHFEmcQA::kElectronPDG); // no accept cut
        }

      } // end of MC QA loop
    }

    fCFM->SetMCEventInfo(fInputEvent);
  }
  // Run MC loop
  AliVParticle *mctrack = NULL;
  Int_t numberofmctracks = 0;
  if(IsESDanalysis()){
    numberofmctracks = fMCEvent->GetNumberOfTracks();
  }
  else {
    numberofmctracks = fAODArrayMCInfo->GetEntriesFast();
  }
  AliDebug(3, Form("Number of Tracks: %d",numberofmctracks));
  //printf("Number of MC track %d\n",numberofmctracks);
  for(Int_t imc = 0; imc <numberofmctracks; imc++){
    if(IsESDanalysis()) {
      if(!(mctrack = fMCEvent->GetTrack(imc))) continue;
    }
    else {
      if(!(mctrack = (AliVParticle *) fAODArrayMCInfo->At(imc))) continue;
    }
    //printf("Test in ProcessMC\n");
    AliDebug(4, "Next MC Track");
    if(ProcessMCtrack(mctrack)) nElectrons++;
  }

  // fCFM->CheckEventCuts(AliCFManager::kEvtRecCuts, fESD);
  fQACollection->Fill("nElectron", nElectrons);
}

//____________________________________________________________
void AliAnalysisTaskHFE::ProcessESD(){
  //
  // Run Analysis of reconstructed event in ESD Mode
  // Loop over Tracks, filter according cut steps defined in AliHFEcuts
  //
  AliDebug(1, Form("Task %s", GetName()));
  AliDebug(3, "Processing ESD Event");
  AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);
  if(!fESD){
    AliError("ESD Event required for ESD Analysis");
    return;
  }

  // Set magnetic field if V0 task on
  if(fTaggedTrackAnalysis) {
    // Tag all v0s in current event
    if(fV0Tagger){
      fV0Tagger->Reset();
      fV0Tagger->TagV0Tracks(fESD);
    }
    fTaggedTrackAnalysis->SetMagneticField(fESD->GetMagneticField());
    fTaggedTrackAnalysis->SetCentrality(fCentralityF);
    if(IsPbPb()) fTaggedTrackAnalysis->SetPbPb();
    else {
	    if(IspPb()) fTaggedTrackAnalysis->SetpPb();
	    else fTaggedTrackAnalysis->SetPP();
    }
  }

  // Do event Normalization
  Double_t eventContainer[4];
  eventContainer[0] = 0.; 
  if(HasMCData()) eventContainer[0] = fVz;
  else {
    const AliESDVertex* vtxESD = fESD->GetPrimaryVertex();
    if(vtxESD) eventContainer[0] = vtxESD->GetZ();
  }
  eventContainer[1] = 0.;
  eventContainer[2] = fCentralityF;
  eventContainer[3] = fContributors;
  if(fTriggerAnalysis->IsOfflineTriggerFired(fESD, AliTriggerAnalysis::kV0AND))
    eventContainer[1] = 1.;

  //
  fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoCut);

  //
  if(fIdentifiedAsPileUp) return; 
  fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoPileUp);

  //
  if(TMath::Abs(fCentralityF) < 0) return; 
  fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecCentralityOk);
  //printf("In ProcessESD %f\n",fCentralityF);

  //
  if(fIdentifiedAsOutInz) return;
  fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepZRange);  

  //
  if(!fPassTheEventCut) return;
  fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepReconstructed);


  fContainer->NewEvent();

  if (GetPlugin(kIsElecBackGround)) { 
    fElecBackGround->SetEvent(fESD);
  }
  if (GetPlugin(kSecVtx)) {
    fSecVtx->SetEvent(fESD);
    fSecVtx->GetPrimaryCondition();
  }

  if(HasMCData()){
    if (GetPlugin(kSecVtx)) { 
      fSecVtx->SetMCEvent(fMCEvent);
      fSecVtx->SetMCQA(fMCQA); 
    }
    if (GetPlugin(kIsElecBackGround)) { 
      fElecBackGround->SetMCEvent(fMCEvent);
    }
  }

  Double_t container[10];
  memset(container, 0, sizeof(Double_t) * 10);
  // container for the output THnSparse
  Double_t dataDca[6]; // [source, pT, dca, centrality]
  Int_t nElectronCandidates = 0;
  AliESDtrack *track = NULL, *htrack = NULL;
  AliMCParticle *mctrack = NULL;
  AliMCParticle *mctrackmother = NULL;

  Bool_t signal = kTRUE;

  fCFM->SetRecEventInfo(fESD);

  // Get Number of contributors to the primary vertex for multiplicity-dependent correction
  Int_t ncontribVtx = 0;
  const AliESDVertex *priVtx = fESD->GetPrimaryVertexTracks();
  if(priVtx){
    ncontribVtx = priVtx->GetNContributors();
  }

  // minjung for IP QA(temporary ~ 2weeks)
  if(!fExtraCuts){
    fExtraCuts = new AliHFEextraCuts("hfetmpCuts","HFE tmp Cuts");
  }
  fExtraCuts->SetRecEventInfo(fESD);

  // Electron background analysis 
  if (GetPlugin(kIsElecBackGround)) {

    AliDebug(2, "Running BackGround Analysis");

    fElecBackGround->Reset();

  } // end of electron background analysis


  // Background subtraction-------------------------------------------------------------------
  if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent, fCentralityF);
  //------------------------------------------------------------------------------------------

  //
  // Loop ESD
  //
  AliDebug(3, Form("Number of Tracks: %d", fESD->GetNumberOfTracks()));
  Bool_t kinkmother(kFALSE), kinkdaughter(kFALSE); Double_t kinkstatus(0);
  for(Int_t itrack = 0; itrack < fESD->GetNumberOfTracks(); itrack++){
    AliDebug(4, "New ESD track");
    track = fESD->GetTrack(itrack);
    track->SetESDEvent(fESD);
    kinkmother = track->GetKinkIndex(0) < 0; kinkdaughter = track->GetKinkIndex(0) > 0;
    kinkstatus = 0.;
    if(kinkmother) kinkstatus = 1.;
    else if(kinkdaughter) kinkstatus = 2.;

    // fill counts of v0-identified particles
    AliPID::EParticleType v0pid = fV0Tagger ? fV0Tagger->GetV0Info(track->GetID()) : AliPID::kUnknown;
    // here the tagged track analysis will run
    if(fTaggedTrackAnalysis && v0pid != AliPID::kUnknown){ 
      AliDebug(1, Form("Track identified as %s", AliPID::ParticleName(v0pid)));
      fTaggedTrackAnalysis->ProcessTrack(track, v0pid);
      AliDebug(1, "V0 PID done");
    }
 

    //Fill non-HFE source containers at reconstructed events cut step
    AliDebug(3, Form("Doing track %d, %p", itrack, track));


    //////////////////////////////////////
    // preselect
    //////////////////////////////////////
    if(fPIDpreselect || fCutspreselect) {
      if(!PreSelectTrack(track)) continue;
    }

    signal = kTRUE;
    
    // Fill step without any cut
          
    if(HasMCData()){
      // Check if it is electrons near the vertex
      if(!(mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(track->GetLabel()))))) continue;

      if(fFillSignalOnly && !fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, mctrack)) signal = kFALSE; 
      if(fRejectMCFakeTracks && IsMCFakeTrack(track)) signal = kFALSE;
      else AliDebug(3, "Signal Electron");

      // Fill K pt for Ke3 contributions
      if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode())==321)) fQACollection->Fill("Kptspectra",mctrack->Pt());
      else if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode())==130)) fQACollection->Fill("K0Lptspectra",mctrack->Pt());
    } 
    // Cache new Track information inside the var manager
    fVarManager->NewTrack(track, mctrack, fCentralityF, -1, signal);

    if(fFillNoCuts) {
      if(signal || !fFillSignalOnly){
        fVarManager->FillContainer(fContainer, "recTrackContReco", AliHFEcuts::kStepRecNoCut, kFALSE);
        fVarManager->FillContainer(fContainer, "recTrackContMC", AliHFEcuts::kStepRecNoCut, kTRUE);
      }
    }
  
    // RecKine: ITSTPC cuts  
    if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;
    
    fQACollection->Fill("Kinkbefore", track->Pt(), kinkstatus); 
    // RecPrim
    if(fRejectKinkMother) { 
      if(track->GetKinkIndex(0) != 0) continue; } // Quick and dirty fix to reject both kink mothers and daughters
    if(!ProcessCutStep(AliHFEcuts::kStepRecPrim, track)) continue;
    fQACollection->Fill("Kinkafter", track->Pt(), kinkstatus); 

    // production radius
    Double_t pradius[3] = {(Double_t)fCentralityF,track->Pt(),-1.};
    Bool_t fill = kFALSE;
    if(HasMCData()){
      Int_t labelr = track->GetLabel();
      if(labelr >=0) {
	AliMCParticle *mctrackk = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(labelr));
	if(mctrackk && (TMath::Abs(mctrackk->Particle()->GetPdgCode()) == 11)) {
	  Int_t motherlabel = mctrackk->Particle()->GetFirstMother();
	  if(motherlabel >= 0){
	    AliMCParticle *mothertrack = NULL;
	    if((mothertrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(motherlabel)))){
	      TParticle * mother = mothertrack->Particle();
	      Int_t  pdgmother = mother->GetPdgCode();
	      if(pdgmother == 22) {
		pradius[2] = mctrackk->Particle()->R();
		fill = kTRUE;
	      }
	    }
	  }
	}
      }
      if(fill)  fQACollection->Fill("RadiusBefore", pradius); 
    }

    // HFEcuts: ITS layers cuts
    if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsITS, track)) continue;
  
    // production vertex
    if(fill)  {
      fQACollection->Fill("RadiusAfter", pradius); 
      FillProductionVertex(track);
    }
  
    // HFE cuts: TOF PID and mismatch flag
    if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTOF, track)) continue;

    // HFE cuts: TPC PID cleanup
    if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTPC, track)) continue;

    // HFEcuts: Nb of tracklets TRD0
    if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTRD, track)) continue;

    // Fill correlation maps before PID
    if(signal && fContainer->GetCorrelationMatrix("correlationstepbeforePID")) {
      //printf("Fill correlation maps before PID\n");
      fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepbeforePID"));
    }

    if(HasMCData()){
      //FillProductionVertex(track);

      if(fMCQA && signal){
        fMCQA->SetCentrality(fCentralityF);
        if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 11)){
         Double_t weightElecBgV0[kBgLevels] = {0.,0.,0.};
         Double_t hfeimpactRtmp=0., hfeimpactnsigmaRtmp=0.;
         fExtraCuts->GetHFEImpactParameters(track, hfeimpactRtmp, hfeimpactnsigmaRtmp);
         UChar_t itsPixel = track->GetITSClusterMap();
         Double_t ilyrhit=0, ilyrstat=0;
         for(Int_t ilyr=0; ilyr<6; ilyr++){
           if(TESTBIT(itsPixel, ilyr)) ilyrhit += TMath::Power(2,ilyr);
           if(fExtraCuts->CheckITSstatus(fExtraCuts->GetITSstatus(track,ilyr))) ilyrstat += TMath::Power(2,ilyr);
         }
         fMCQA->SetITSInfo(ilyrhit,ilyrstat);
         fMCQA->SetHFEImpactParameters(hfeimpactRtmp, hfeimpactnsigmaRtmp);
         fMCQA->SetTrkKine(track->Pt(),track->Eta(), track->Phi());
         fMCQA->SetContainerStep(3);
         for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
           weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE 
           if(!fisNonHFEsystematics || IsPbPb())break;   
         }
         
         if(fisNonHFEsystematics){
           //Fill additional containers for electron source distinction
           Int_t elecSource = 0;
           elecSource = fMCQA->GetElecSource(mctrack->Particle(), kTRUE);
           const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};
           const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};
           Int_t iName = 0;
           for(Int_t iSource = AliHFEmcQA::kPi0; iSource <=  AliHFEmcQA::kGammaRho0; iSource++){
             if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;
             if(elecSource == iSource){
               for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
                 if(weightElecBgV0[iLevel]>0){ 
                   fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 3, kFALSE, weightElecBgV0[iLevel]);
                 } 
                 else if(weightElecBgV0[iLevel]<0){ 
                   fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 3, kFALSE, -1*weightElecBgV0[iLevel]);
                 }
                 if(IsPbPb())break;
               }
               break;
             }
             iName++;
             if(iName == kElecBgSpecies)iName = 0;
           }
         }
         //else{
           if(weightElecBgV0[0]>0) {
	     fVarManager->FillContainer(fContainer, "conversionElecs", 3, kFALSE, weightElecBgV0[0]);
	     fVarManager->FillContainer(fContainer, "conversionElecs", 4, kTRUE, weightElecBgV0[0]);
	   }
           else if(weightElecBgV0[0]<0) {
	     fVarManager->FillContainer(fContainer, "mesonElecs", 3, kFALSE, -1*weightElecBgV0[0]);
	     fVarManager->FillContainer(fContainer, "mesonElecs", 4, kTRUE, -1*weightElecBgV0[0]);
	   }
           //}
        }
      }

      Double_t hfeimpactR4all=0., hfeimpactnsigmaR4all=0.;
      Int_t sourceDca =-1;
      if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 211)){
        if(track->Pt()>4.){
          fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);
          dataDca[0]=0; //pion
          dataDca[1]=track->Pt();
          dataDca[2]=hfeimpactR4all;
          dataDca[3]=fCentralityF;
          dataDca[4] = v0pid;
          dataDca[5] = double(track->Charge());
          fQACollection->Fill("Dca", dataDca);
        }
      }
      else if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 11)){ // to increas statistics for Martin
        if(signal){
          fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);
          if(fSignalCuts->IsCharmElectron(track)){
            sourceDca=1;
          }
          else if(fSignalCuts->IsBeautyElectron(track)){
            sourceDca=2;
          }
          else if(fSignalCuts->IsGammaElectron(track)){
            sourceDca=3;
          }
          else if(fSignalCuts->IsNonHFElectron(track)){
            sourceDca=4;
          }
          else if(fSignalCuts->IsJpsiElectron(track)){
            sourceDca=5;
          }
          else {
            sourceDca=6;
          }
          dataDca[0]=sourceDca;
          dataDca[1]=track->Pt();
          dataDca[2]=hfeimpactR4all;
          dataDca[3]=fCentralityF;
          dataDca[4] = v0pid;
          dataDca[5] = double(track->Charge());
          if(signal) fQACollection->Fill("Dca", dataDca);
        }
      }
    }

    AliHFEpidObject hfetrack;
    hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);
    hfetrack.SetRecTrack(track);
    if(HasMCData()) hfetrack.SetMCTrack(mctrack);
    hfetrack.SetCentrality(fCentralityF);
    hfetrack.SetMulitplicity(ncontribVtx);
    if(IsPbPb()) hfetrack.SetPbPb();
    else {
	if(IspPb()) hfetrack.SetpPb();
	else hfetrack.SetPP();
    }
    fPID->SetVarManager(fVarManager);
    if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue;
    nElectronCandidates++;
    
    // Background subtraction------------------------------------------------------------------------------------------
    if (GetPlugin(kNonPhotonicElectron)&&!GetPlugin(kNonPhotonicElectronBeauty)) {
      Int_t indexmother = -1;
      Int_t mcsource = -1;
      Int_t mcQAsource = -1;
      Double_t weightNonPhotonicFactor = 1.; 
      if(HasMCData()){
	mcsource = fBackgroundSubtraction->FindMother(mctrack->GetLabel(),indexmother);
	if(fBackgroundSubtraction->GetLevelBack()>=0) {
	  if(fMCQA) {
	    fMCQA->SetCentrality(fCentralityF);
	    fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));
	    mcQAsource = fMCQA->GetElecSource(mctrack, kTRUE);
	    weightNonPhotonicFactor = TMath::Abs(fMCQA->GetWeightFactor(mctrack, fBackgroundSubtraction->GetLevelBack())); // positive:conversion e, negative: nonHFE 
	  }
	}
      }
      fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, weightNonPhotonicFactor, fCentralityF, -1, mcsource, indexmother,mcQAsource);
    }
    //-----------------------------------------------------------------------------------------------------------------

    // Temporary histogram for chi2/ITS cluster
    if(IsPbPb()) {
      TBits shared = track->GetTPCSharedMap();
	    Int_t sharebit=0;
      if(shared.CountBits() >= 2) sharebit=1;

	    Double_t itschi2percluster = 0.0;
	    Double_t itsnbcls = static_cast<Double_t>(track->GetNcls(0));
	    if(itsnbcls > 0) itschi2percluster = track->GetITSchi2()/itsnbcls;

      Double_t itsChi2[7] = {track->Pt(),track->Eta(), track->Phi(),
			static_cast<Double_t>(fCentralityF),static_cast<Double_t>(track->GetTPCsignalN()), static_cast<Double_t>(sharebit),itschi2percluster};
      fQACollection->Fill("fChi2perITScluster", itsChi2);
    }
    else{

      Double_t itschi2percluster = 0.0;
      Double_t itsnbcls = static_cast<Double_t>(track->GetNcls(0));
      if(itsnbcls > 0) itschi2percluster = track->GetITSchi2()/itsnbcls;

      Double_t itsChi2[3] = {track->Pt(), static_cast<Double_t>(fCentralityF), itschi2percluster};
      fQACollection->Fill("fChi2perITScluster", itsChi2);
    }

    // Fill Histogram for Hadronic Background
    if(HasMCData()){
      if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11))
        fVarManager->FillContainer(fContainer, "hadronicBackground", UInt_t(0), kFALSE);
      else if(mctrack){
        // Fill Ke3 contributions
        Int_t glabel=TMath::Abs(mctrack->GetMother());
        if((mctrackmother = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(glabel)))){
          if(TMath::Abs(mctrackmother->Particle()->GetPdgCode())==321)
            fQACollection->Fill("Ke3Kecorr",mctrack->Pt(),mctrackmother->Pt());
          else if(TMath::Abs(mctrackmother->Particle()->GetPdgCode())==130)
            fQACollection->Fill("Ke3K0Lecorr",mctrack->Pt(),mctrackmother->Pt());
        }
      }
    }

    // Fill Containers
    if(signal) {
      // Apply weight for background contamination
      if(fBackGroundFactorApply) {
        if(IsPbPb() && fCentralityF >= 0) fWeightBackGround =  fkBackGroundFactorArray[fCentralityF >= 0 ? fCentralityF : 0]->Eval(TMath::Abs(track->P()));
        else    fWeightBackGround =  fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // for pp and pPb

        if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
        else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
        // weightBackGround as special weight
        fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, fWeightBackGround);
      }
      fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterPID"));
    }

    Bool_t bTagged=kFALSE;
    if(GetPlugin(kSecVtx)) {
      AliDebug(2, "Running Secondary Vertex Analysis");
      if(fSecVtx->Process(track) && signal) {
        fVarManager->FillContainer(fContainer, "recTrackContSecvtxReco", AliHFEcuts::kStepHFEcutsSecvtx, kFALSE);
        fVarManager->FillContainer(fContainer, "recTrackContSecvtxMC", AliHFEcuts::kStepHFEcutsSecvtx, kTRUE);
        bTagged=kTRUE;
      }
    }

    // Electron background analysis 
    if (GetPlugin(kIsElecBackGround)) {
      
      AliDebug(2, "Running BackGround Analysis");
      
      for(Int_t jtrack = 0; jtrack < fESD->GetNumberOfTracks(); jtrack++){
        htrack = fESD->GetTrack(jtrack);
        if ( itrack == jtrack ) continue;  
        fElecBackGround->PairAnalysis(track, htrack); 
      }
    } // end of electron background analysis

    if (GetPlugin(kDEstep)) { 
      Double_t weightElecBgV0[kBgLevels] = {0.,0.,0.,};
      Int_t elecSource = 0;
      Double_t hfeimpactR=0., hfeimpactnsigmaR=0.;
      fExtraCuts->GetHFEImpactParameters(track, hfeimpactR, hfeimpactnsigmaR);
      if(HasMCData())
      {
        if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)){
            fQACollection->Fill("hadronsBeforeIPcut",track->Pt());
        } 
        if(fMCQA && signal) {
          
          fMCQA->SetContainerStep(0);
          for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
            weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE 
            if(!fisNonHFEsystematics || IsPbPb())break;        
          }
          
          if(fisNonHFEsystematics){
            //Fill additional containers for electron source distinction           
            elecSource = fMCQA->GetElecSource(mctrack->Particle(), kTRUE);
            const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};
            const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};
            Int_t iName = 0;
            for(Int_t iSource = AliHFEmcQA::kPi0; iSource <=  AliHFEmcQA::kGammaRho0; iSource++){
              if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;
              if(elecSource == iSource){
                for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
                  if(weightElecBgV0[iLevel]>0) fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 0, kFALSE, weightElecBgV0[iLevel]);
                  else if(weightElecBgV0[iLevel]<0) fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 0, kFALSE, -1*weightElecBgV0[iLevel]);
                  if(IsPbPb())break;
                }
                break;
              }
              iName++;
              if(iName == kElecBgSpecies)iName = 0;
            }
          }
          //else{
          if(weightElecBgV0[0]>0) {
	    fVarManager->FillContainer(fContainer, "conversionElecs", 0, kFALSE, weightElecBgV0[0]);
	    fVarManager->FillContainer(fContainer, "conversionElecs", 5, kTRUE, weightElecBgV0[0]);
	  }
          else if(weightElecBgV0[0]<0) {
	    fVarManager->FillContainer(fContainer, "mesonElecs", 0, kFALSE, -1*weightElecBgV0[0]);
	    fVarManager->FillContainer(fContainer, "mesonElecs", 5, kTRUE, -1*weightElecBgV0[0]);
	  }  
          //}
          if(bTagged){ // bg estimation for the secondary vertex tagged signals
            if(weightElecBgV0[0]>0) fVarManager->FillContainer(fContainer, "conversionElecs", 2, kFALSE, weightElecBgV0[0]);
            else if(weightElecBgV0[0]<0) fVarManager->FillContainer(fContainer, "mesonElecs", 2, kFALSE, -1*weightElecBgV0[0]);
          }
        }
      } // end of MC

      dataDca[0]=-1; //for data, don't know the origin
      dataDca[1]=track->Pt();
      dataDca[2]=hfeimpactR;
      dataDca[3]=fCentralityF;
      dataDca[4] = v0pid;
      dataDca[5] = double(track->Charge());
      if (!HasMCData()) fQACollection->Fill("Dca", dataDca);

      // Fill Containers for impact parameter analysis
      if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsDca + AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack,track)) continue;
      if(signal) {
        // Apply weight for background contamination after ip cut
        if(fBackGroundFactorApply) {
              fWeightBackGround =  fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case
              if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
              else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
              // weightBackGround as special weight
              fVarManager->FillContainer(fContainer, "hadronicBackground", 2, kFALSE, fWeightBackGround);
        }
      }

      if(HasMCData()){
        if(fMCQA && signal) {
          fMCQA->SetContainerStep(1);
          for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
            weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE 
            if(!fisNonHFEsystematics || IsPbPb())break;        
          }       
          if(fisNonHFEsystematics){
            //Fill additional containers for electron source distinction             
            elecSource = fMCQA->GetElecSource(mctrack->Particle(), kTRUE);
            const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};
            const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};
            Int_t iName = 0;
            for(Int_t iSource = AliHFEmcQA::kPi0; iSource <=  AliHFEmcQA::kGammaRho0; iSource++){
              if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;
              if(elecSource == iSource){
                for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
                  if(weightElecBgV0[iLevel]>0) fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 1, kFALSE, weightElecBgV0[iLevel]);
                  else if(weightElecBgV0[iLevel]<0) fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 1, kFALSE, -1*weightElecBgV0[iLevel]);
                  if(IsPbPb())break;
                }
                break;
              }
              iName++;
              if(iName == kElecBgSpecies)iName = 0;
            }
          }
          // else{
            if(weightElecBgV0[0]>0) {
	      fVarManager->FillContainer(fContainer, "conversionElecs", 1, kFALSE, weightElecBgV0[0]);
	      fVarManager->FillContainer(fContainer, "conversionElecs", 6, kTRUE, weightElecBgV0[0]);
	    }
            else if(weightElecBgV0[0]<0) {
	      fVarManager->FillContainer(fContainer, "mesonElecs", 1, kFALSE, -1*weightElecBgV0[0]);
	      fVarManager->FillContainer(fContainer, "mesonElecs", 6, kTRUE, -1*weightElecBgV0[0]);
            }
            //}
        }
      }
      if(signal) {
        fVarManager->FillContainer(fContainer, "recTrackContDEReco", AliHFEcuts::kStepHFEcutsDca, kFALSE);
        fVarManager->FillContainer(fContainer, "recTrackContDEMC", AliHFEcuts::kStepHFEcutsDca, kTRUE);
        fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterDE"));
      }
      if(HasMCData()){
        if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)){
          fQACollection->Fill("hadronsAfterIPcut",track->Pt());
        }
      }
    }

    // Background subtraction------------------------------------------------------------------------------------------
    if (!GetPlugin(kNonPhotonicElectron)&&GetPlugin(kNonPhotonicElectronBeauty)) {
      Int_t indexmother = -1;
      Int_t mcsource = -1;
      Int_t mcQAsource = -1;
      Double_t weightNonPhotonicFactor = 1.;
      if(HasMCData()){
        mcsource = fBackgroundSubtraction->FindMother(mctrack->GetLabel(),indexmother);
        if(fBackgroundSubtraction->GetLevelBack()>=0) {
          if(fMCQA) {
            fMCQA->SetCentrality(fCentralityF);
            fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));
            mcQAsource = fMCQA->GetElecSource(mctrack, kTRUE);
            weightNonPhotonicFactor = TMath::Abs(fMCQA->GetWeightFactor(mctrack, fBackgroundSubtraction->GetLevelBack())); // positive:conversion e, negative: nonHFE 
          }
        }
      }
      fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, weightNonPhotonicFactor, fCentralityF, -1, mcsource, indexmother,mcQAsource);
    }
    //-----------------------------------------------------------------------------------------------------------------
  }

  // Background subtraction-------------------------------------------------------------------
  if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->CountPoolAssociated(fInputEvent, fCentralityF);
  //------------------------------------------------------------------------------------------

  fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);
}

//____________________________________________________________
void AliAnalysisTaskHFE::ProcessAOD(){
  //
  // Run Analysis in AOD Mode
  // Function is still in development
  //
  //printf("Process AOD\n");
  AliDebug(3, "Processing AOD Event");
  Double_t eventContainer[4];
  eventContainer[0] = 0.0;
  if(HasMCData()) eventContainer[0] = fVz;
  else {
    if(fInputEvent->GetPrimaryVertex()) eventContainer[0] = fInputEvent->GetPrimaryVertex()->GetZ();
  }
  eventContainer[1] = 1.; // No Information available in AOD analysis, assume all events have V0AND
  eventContainer[2] = fCentralityF; 
  eventContainer[3] = fContributors; 
  
  //printf("value event container %f, %f, %f, %f\n",eventContainer[0],eventContainer[1],eventContainer[2],eventContainer[3]);

  AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);
  if(!fAOD){
    AliError("AOD Event required for AOD Analysis");
      return;
  }

  // Set magnetic field if V0 task on
  if(fTaggedTrackAnalysis) {
    // Tag all v0s in current event
    if(fV0Tagger){
      fV0Tagger->Reset();
      fV0Tagger->TagV0Tracks(fAOD);
    }
    fTaggedTrackAnalysis->SetMagneticField(fAOD->GetMagneticField());
    fTaggedTrackAnalysis->SetCentrality(fCentralityF);
    if(IsPbPb()) fTaggedTrackAnalysis->SetPbPb();
    else {
      if(IspPb()) fTaggedTrackAnalysis->SetpPb();
      else fTaggedTrackAnalysis->SetPP();
    }
  }
  
  //printf("Will fill\n");
  //
  fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoCut);
  //printf("Fill\n");
  //
  if(fIdentifiedAsPileUp) return; 
  fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoPileUp);

  //
  if(fIdentifiedAsOutInz) return;
  fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepZRange);  

  //
  if(!fPassTheEventCut) return;
  fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepReconstructed);
  //printf("pass\n");

  fContainer->NewEvent();

  fCFM->SetRecEventInfo(fAOD);

  if(!fExtraCuts){
    fExtraCuts = new AliHFEextraCuts("hfeExtraCuts","HFE Extra Cuts");
  }
  fExtraCuts->SetRecEventInfo(fAOD);

  // Get Number of contributors to the primary vertex for multiplicity-dependent correction
  Int_t ncontribVtx = 0;
  AliAODVertex *priVtx = fAOD->GetPrimaryVertex();
  if(priVtx){
    ncontribVtx = priVtx->GetNContributors();
  }

  // Look for kink mother
  Int_t numberofvertices = fAOD->GetNumberOfVertices();
  Double_t listofmotherkink[numberofvertices];
  Int_t numberofmotherkink = 0;
  for(Int_t ivertex=0; ivertex < numberofvertices; ivertex++) {
    AliAODVertex *aodvertex = fAOD->GetVertex(ivertex);
    if(!aodvertex) continue;
    if(aodvertex->GetType()==AliAODVertex::kKink) {
      AliAODTrack *mother = (AliAODTrack *) aodvertex->GetParent();
      if(!mother) continue;
      Int_t idmother = mother->GetID();
      listofmotherkink[numberofmotherkink] = idmother;
      //printf("ID %d\n",idmother);
      numberofmotherkink++;
    }
  }
  //printf("Number of kink mother in the events %d\n",numberofmotherkink);

  // Background subtraction-------------------------------------------------------------------
  if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent, fCentralityF);
  //------------------------------------------------------------------------------------------

  // Loop over tracks
  AliAODTrack *track = NULL;
  AliAODMCParticle *mctrack = NULL;
  Double_t dataDca[6]; // [source, pT, dca, centrality]
  Int_t nElectronCandidates = 0;
  Bool_t signal;

  //printf("Number of track %d\n",(Int_t) fAOD->GetNumberOfTracks());
  Bool_t kinkmother(kFALSE), kinkdaughter(kFALSE); Double_t kinkstatus(0);
  for(Int_t itrack = 0; itrack < fAOD->GetNumberOfTracks(); itrack++){
    kinkmother=kFALSE;
    kinkdaughter=kFALSE;
    kinkstatus = 0.;
    track = (AliAODTrack *) fAOD->GetTrack(itrack); mctrack = NULL;
    if(!track) continue;

    for(int ivx = 0; ivx < numberofmotherkink; ivx++){
      if(track->GetID() == listofmotherkink[ivx]){
        kinkmother = kTRUE;
        break;
      }
    }
    AliAODVertex *pvx = track->GetProdVertex();
    if(pvx && (pvx->GetType() == AliAODVertex::kKink)) kinkdaughter = kTRUE;
    kinkstatus = 0.;
    if(kinkmother) kinkstatus = 1.;
    else if(kinkdaughter) kinkstatus = 2.;

    // fill counts of v0-identified particles
    AliPID::EParticleType v0pid = fV0Tagger ? fV0Tagger->GetV0Info(track->GetID()) : AliPID::kUnknown;
    // here the tagged track analysis will run
    if(fTaggedTrackAnalysis && v0pid != AliPID::kUnknown){ 
      AliDebug(1, Form("Track identified as %s", AliPID::ParticleName(v0pid)));
      fTaggedTrackAnalysis->ProcessTrack(track, v0pid);
      AliDebug(1, "V0 PID done");
    }
    
    signal = kTRUE;
    if(HasMCData()){
      Int_t label = TMath::Abs(track->GetLabel());
      if(label && label < fAODArrayMCInfo->GetEntriesFast())
        mctrack = dynamic_cast<AliAODMCParticle *>(fAODArrayMCInfo->At(label));
        if(fFillSignalOnly && !fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, mctrack)) signal = kFALSE;
        if(fRejectMCFakeTracks && IsMCFakeTrack(track)) signal = kFALSE;
    }
    
    fVarManager->NewTrack(track, mctrack, fCentralityF, -1, signal);
    
    if(fFillNoCuts) {
      if(signal || !fFillSignalOnly){
        fVarManager->FillContainer(fContainer, "recTrackContReco", AliHFEcuts::kStepRecNoCut, kFALSE);
        fVarManager->FillContainer(fContainer, "recTrackContMC", AliHFEcuts::kStepRecNoCut, kTRUE);
      }
    }

    // begin AOD QA
    fQACollection->Fill("Filterbegin", -1);  
    for(Int_t k=0; k<20; k++) {
      Int_t u = 1<<k;
      if((track->TestFilterBit(u))) {
	    fQACollection->Fill("Filterbegin", k);
      }
    }

    // RecKine: ITSTPC cuts  
    if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;

    fQACollection->Fill("Kinkbefore", track->Pt(), kinkstatus); 
    // Reject kink mother
    if(fRejectKinkMother) {
      Bool_t kinkmotherpass = kTRUE;
      for(Int_t ikinkmother = 0; ikinkmother < numberofmotherkink; ikinkmother++) {
        if(track->GetID() == listofmotherkink[ikinkmother]) {
          kinkmotherpass = kFALSE;
          continue;
        }
      }
      if(!kinkmotherpass) continue;
    }       

    // RecPrim
    if(!ProcessCutStep(AliHFEcuts::kStepRecPrim, track)) continue;
    fQACollection->Fill("Kinkafter", track->Pt(), kinkstatus); 

    // production radius
    Double_t pradius[3] = {(Double_t)fCentralityF,track->Pt(),-1.};
    Bool_t fill = kFALSE;
    if(HasMCData()){
      Int_t labelr = track->GetLabel();
      if(labelr>=0) {
	AliAODMCParticle *mctrackk = dynamic_cast<AliAODMCParticle *>(fAODArrayMCInfo->At(labelr));
	if(mctrackk && (TMath::Abs(mctrackk->GetPdgCode()) == 11)) {
	  Int_t motherlabel = mctrackk->GetMother();
	  if((motherlabel>=0) && (motherlabel < fAODArrayMCInfo->GetEntriesFast())) {
	    AliAODMCParticle *mcmothertrack = dynamic_cast<AliAODMCParticle *>(fAODArrayMCInfo->At(motherlabel));
	    if(mcmothertrack && (TMath::Abs(mcmothertrack->GetPdgCode()) == 22)) {
	      pradius[2] = TMath::Sqrt(mctrackk->Xv()*mctrackk->Xv()+mctrackk->Yv()*mctrackk->Yv());
	      fill = kTRUE;
	    }
	  }
	}
      }
      if(fill)  fQACollection->Fill("RadiusBefore", pradius); 
    }

    // HFEcuts: ITS layers cuts
    if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsITS, track)) continue;

    // production radius
    if(fill) fQACollection->Fill("RadiusAfter", pradius); 
      
    // HFE cuts: TOF PID and mismatch flag
    if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTOF, track)) continue;
      
    // HFE cuts: TPC PID cleanup
    if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTPC, track)) continue;
    
    // HFEcuts: Nb of tracklets TRD0
    if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTRD, track)) continue;

    // Fill correlation maps before PID
    if(signal && fContainer->GetCorrelationMatrix("correlationstepbeforePID")) {
      //printf("Fill correlation maps before PID\n");
      fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepbeforePID"));
    }

    if(HasMCData()){

      if(fMCQA && signal){
        fMCQA->SetCentrality(fCentralityF);
        if(mctrack && (TMath::Abs(mctrack->GetPdgCode()) == 11)){
         Double_t weightElecBgV0[kBgLevels] = {0.,0.,0.};
         for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
           weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE 
         }
         if(weightElecBgV0[0]>0) {
             fVarManager->FillContainer(fContainer, "conversionElecs", 3, kFALSE, weightElecBgV0[0]);
             fVarManager->FillContainer(fContainer, "conversionElecs", 4, kTRUE, weightElecBgV0[0]);
         }
         else if(weightElecBgV0[0]<0) {
             fVarManager->FillContainer(fContainer, "mesonElecs", 3, kFALSE, -1*weightElecBgV0[0]);
             fVarManager->FillContainer(fContainer, "mesonElecs", 4, kTRUE, -1*weightElecBgV0[0]);
         }
        }
      }

      Double_t hfeimpactR4all=0., hfeimpactnsigmaR4all=0.;
      Int_t sourceDca =-1;
      if(mctrack && (TMath::Abs(mctrack->GetPdgCode()) == 211)){
        if(track->Pt()>4.){
          fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);
          dataDca[0]=0; //pion
          dataDca[1]=track->Pt();
          dataDca[2]=hfeimpactR4all;
          dataDca[3]=fCentralityF;
          dataDca[4] = -1; // not store V0 for the moment
          dataDca[5] = double(track->Charge());
          fQACollection->Fill("Dca", dataDca);
        }
      }
      else if(mctrack && (TMath::Abs(mctrack->GetPdgCode()) == 11)){ // to increas statistics for Martin
        if(signal){
          fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);
          if(fSignalCuts->IsCharmElectron(track)){
            sourceDca=1;
          }
          else if(fSignalCuts->IsBeautyElectron(track)){
            sourceDca=2;
          }
          else if(fSignalCuts->IsGammaElectron(track)){
            sourceDca=3;
          }
          else if(fSignalCuts->IsNonHFElectron(track)){
            sourceDca=4;
          }
          else if(fSignalCuts->IsJpsiElectron(track)){
            sourceDca=5;
          }
          else {
            sourceDca=6;
          }
          dataDca[0]=sourceDca;
          dataDca[1]=track->Pt();
          dataDca[2]=hfeimpactR4all;
          dataDca[3]=fCentralityF;
          dataDca[4] = -1; // not store V0 for the moment
          dataDca[5] = double(track->Charge());
          if(signal) fQACollection->Fill("Dca", dataDca);
        }
      }
    }

    //printf("Will process to PID\n");

    // track accepted, do PID
    AliHFEpidObject hfetrack;
    hfetrack.SetAnalysisType(AliHFEpidObject::kAODanalysis);
    hfetrack.SetRecTrack(track);
    if(HasMCData()) hfetrack.SetMCTrack(mctrack);
    hfetrack.SetCentrality(fCentralityF);
    hfetrack.SetMulitplicity(ncontribVtx); // for correction
    if(IsPbPb()) hfetrack.SetPbPb();
    else{
      if(IspPb()) hfetrack.SetpPb();
      else hfetrack.SetPP();
    }
    fPID->SetVarManager(fVarManager);
    if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue;   
    // we will do PID here as soon as possible

    // Background subtraction----------------------------------------------------------------------------------------------
    if (GetPlugin(kNonPhotonicElectron)&&!GetPlugin(kNonPhotonicElectronBeauty)) {
      Int_t indexmother = -1;
      Int_t mcsource = -1;  
      Int_t mcQAsource = -1;
      Double_t weightNonPhotonicFactor = 1.; 
      //printf("weight %f \n",weightNonPhotonicFactor);
      if(HasMCData() && mctrack){  
        mcsource = fBackgroundSubtraction->FindMother(TMath::Abs(track->GetLabel()),indexmother);
	if(fBackgroundSubtraction->GetLevelBack()>=0) {
	  if(fMCQA) {
	    fMCQA->SetCentrality(fCentralityF);
	    fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));
	    mcQAsource = fMCQA->GetElecSource(mctrack, kTRUE);
	    weightNonPhotonicFactor = TMath::Abs(fMCQA->GetWeightFactor(mctrack, fBackgroundSubtraction->GetLevelBack())); // positive:conversion e, negative: nonHFE 
	    //weightNonPhotonicFactor = TMath::Abs(fMCQA->GetWeightFactorForPrimaries(mctrack, fBackgroundSubtraction->GetLevelBack())); // positive:conversion e, negative: nonHFE 
	  }
	}
      }
	fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, weightNonPhotonicFactor, fCentralityF, -1,mcsource, indexmother,mcQAsource);
    }
    //---------------------------------------------------------------------------------------------------------------------

    // end AOD QA
    fQACollection->Fill("Filterend", -1);  
    for(Int_t k=0; k<20; k++) {
      Int_t u = 1<<k;
      if((track->TestFilterBit(u))) {
	      fQACollection->Fill("Filterend", k);
      }
    }
       
    // Apply weight for background contamination
    //Double_t weightBackGround = 1.0;
    if(signal) {
      // Apply weight for background contamination
      if(fBackGroundFactorApply) {
	      if(IsPbPb() && fCentralityF >= 0) fWeightBackGround =  fkBackGroundFactorArray[fCentralityF >= 0 ? fCentralityF : 0]->Eval(TMath::Abs(track->P()));
	      else    fWeightBackGround =  fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case
	
	      if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
	      else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
        // weightBackGround as special weight
        fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, fWeightBackGround);
      }
      fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterPID"));
    }
    
    nElectronCandidates++;    

    if (GetPlugin(kDEstep)) {
      if (!HasMCData()){
        Double_t hfeimpactR=0., hfeimpactnsigmaR=0.;
        fExtraCuts->GetHFEImpactParameters(track, hfeimpactR, hfeimpactnsigmaR);
        dataDca[0]=-1; //for data, don't know the origin
        dataDca[1]=track->Pt();
        dataDca[2]=hfeimpactR;
        dataDca[3]=fCentralityF;
        dataDca[4] = -1; // not store V0 for the moment
        dataDca[5] = double(track->Charge());
        fQACollection->Fill("Dca", dataDca);
      }

      // Fill Containers for impact parameter analysis
      if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsDca + AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack,track)) continue;
      if(signal) {
        // Apply weight for background contamination after ip cut
        if(fBackGroundFactorApply) {
              fWeightBackGround =  fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case
              if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
              else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
              // weightBackGround as special weight
              fVarManager->FillContainer(fContainer, "hadronicBackground", 2, kFALSE, fWeightBackGround);
        }

        fVarManager->FillContainer(fContainer, "recTrackContDEReco", AliHFEcuts::kStepHFEcutsDca, kFALSE);
        fVarManager->FillContainer(fContainer, "recTrackContDEMC", AliHFEcuts::kStepHFEcutsDca, kTRUE);
        fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterDE"));
      }
    }

    // Background subtraction----------------------------------------------------------------------------------------------
    if (!GetPlugin(kNonPhotonicElectron)&&GetPlugin(kNonPhotonicElectronBeauty)) {
      Int_t indexmother = -1;
      Int_t mcsource = -1;  
      Int_t mcQAsource = -1;
      Double_t weightNonPhotonicFactor = 1.; 
      //printf("weight %f \n",weightNonPhotonicFactor);
      if(HasMCData() && mctrack){  
        mcsource = fBackgroundSubtraction->FindMother(TMath::Abs(track->GetLabel()),indexmother);
	if(fBackgroundSubtraction->GetLevelBack()>=0) {
	  if(fMCQA) {
	    fMCQA->SetCentrality(fCentralityF);
	    fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));
	    mcQAsource = fMCQA->GetElecSource(mctrack, kTRUE);
	    weightNonPhotonicFactor = TMath::Abs(fMCQA->GetWeightFactor(mctrack, fBackgroundSubtraction->GetLevelBack())); // positive:conversion e, negative: nonHFE 
	  }
	}
      }
      fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, weightNonPhotonicFactor, fCentralityF, -1,mcsource, indexmother,mcQAsource);
    }
    //---------------------------------------------------------------------------------------------------------------------

  }

  // Background subtraction-------------------------------------------------------------------
  if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->CountPoolAssociated(fInputEvent, fCentralityF);
  //------------------------------------------------------------------------------------------

  fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);
}

//____________________________________________________________
Bool_t AliAnalysisTaskHFE::ProcessMCtrack(AliVParticle *track){
  //
  // Filter the Monte Carlo Track
  // Additionally Fill a THnSparse for Signal To Background Studies
  // Works for AOD and MC analysis Type
  //
  fVarManager->NewTrack(track, NULL, fCentralityF, -1, kTRUE);
  //printf("Is primary %d\n",((Int_t)track->IsPrimary()));


  Double_t vertex[3] = {0.,0.,0.}; // Production vertex cut to mask gammas which are NOT supposed to have hits in the first ITS layer(s)
  if(IsESDanalysis()){
    AliMCParticle *mctrack = dynamic_cast<AliMCParticle *>(track);
    if(mctrack){
      vertex[0] = mctrack->Particle()->Vx();
      vertex[1] = mctrack->Particle()->Vy();
    }
  } else {
    AliAODMCParticle *aodmctrack = dynamic_cast<AliAODMCParticle *>(track);
    if(aodmctrack) aodmctrack->XvYvZv(vertex);
  }

  //printf("MC Generated\n");
  if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, track)) return kFALSE;
  //printf("MC Generated pass\n");
  fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGenerated, kFALSE);

  // Step GeneratedZOutNoPileUp
  if((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0)) return kFALSE;
  fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGeneratedZOutNoPileUpCentralityFine, kFALSE);
  //printf("In ProcessMCtrack %f\n",fCentralityF);

  // Step Generated Event Cut
  if(!fPassTheEventCut) return kFALSE;
  fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGeneratedEventCut, kFALSE);

  if(IsESDanalysis()){
    if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCInAcceptance, track)) return kFALSE;
    fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCInAcceptance, kFALSE);
  }
  return kTRUE;
}

//____________________________________________________________
Bool_t AliAnalysisTaskHFE::PreSelectTrack(AliESDtrack *track) const {
  //
  // Preselect tracks
  //
  

  Bool_t survived = kTRUE;

  if(fCutspreselect) {
    //printf("test preselect\n");
    if(!fCutspreselect->IsSelected(track)) survived=kFALSE;
  }
  //printf("survived %d\n",(Int_t)survived);
  
  if(survived && fPIDpreselect){
    // Apply PID
    AliHFEpidObject hfetrack;
    hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);
    hfetrack.SetRecTrack(track);
    if(!fPIDpreselect->IsSelected(&hfetrack)) {
      //printf("Did not pass AliHFEcuts::kPID\n");
      survived = kFALSE;
    }
    //else printf("Pass AliHFEcuts::kPID\n");
  }

  return survived; 
      
}
//____________________________________________________________
void AliAnalysisTaskHFE::MakeEventContainer(){
  //
  // Create the event container for the correction framework and link it
  // 1st bin: Vertex z-position
  // 2nd bin: V0AND decision (normalization to sigma_inel)
  // 3rd bin: Centrality class (for pp defined as number of contributors in vertex.)
  // 4th bin: Number of contributors > 0
  //
  
  const Int_t kNvar = 4;  // number of variables on the grid: 
  Int_t nBins[kNvar] = {120, 2, 11, 2};
  Double_t binMin[kNvar] = {-30. , 0., 0.0, 0.};
  Double_t binMax[kNvar] = {30., 2., 11.0, 2.};
  
  AliCFContainer *evCont = new AliCFContainer("eventContainer", "Container for events", AliHFEcuts::kNcutStepsEvent, kNvar, nBins);
  
  Double_t *vertexBins = AliHFEtools::MakeLinearBinning(nBins[0], binMin[0], binMax[0]);
  Double_t *v0andBins = AliHFEtools::MakeLinearBinning(nBins[1], binMin[1], binMax[1]);
  Double_t *centralityBins = AliHFEtools::MakeLinearBinning(nBins[2], binMin[2], binMax[2]);
  Double_t *contributorsBins = AliHFEtools::MakeLinearBinning(nBins[3], binMin[3], binMax[3]);
  evCont->SetBinLimits(0, vertexBins);
  evCont->SetBinLimits(1, v0andBins);
  evCont->SetBinLimits(2, centralityBins);
  evCont->SetBinLimits(3, contributorsBins);
  delete[] vertexBins; delete[] v0andBins; delete[] centralityBins; delete[] contributorsBins;
    
  fCFM->SetEventContainer(evCont);
}

//____________________________________________________________
void AliAnalysisTaskHFE::MakeParticleContainer(){
  //
  // Create the particle container for the correction framework manager and 
  // link it
  //
  if(!fContainer) fContainer = new AliHFEcontainer("trackContainer");
  fVarManager->DefineVariables(fContainer);

  // Create Correction Framework containers
  fContainer->CreateContainer("MCTrackCont", "Track Container filled with MC information", AliHFEcuts::kNcutStepsMCTrack);
  fContainer->CreateContainer("recTrackContReco", "Track Container filled with MC information", AliHFEcuts::kNcutStepsRecTrack + fPID->GetNumberOfPIDdetectors());
  fContainer->CreateContainer("recTrackContMC", "Track Container filled with MC information", AliHFEcuts::kNcutStepsRecTrack + fPID->GetNumberOfPIDdetectors());
  
  fContainer->CreateContainer("hadronicBackground", "Container for Hadronic Background", 3);
  fContainer->CreateContainer("recTrackContDEReco", "Container for displaced electron analysis with Reco information", 1);
  fContainer->CreateContainer("recTrackContDEMC", "Container for displaced electron analysis with MC information", 1);
  fContainer->CreateContainer("recTrackContSecvtxReco", "Container for secondary vertexing analysis with Reco information", 1);
  fContainer->CreateContainer("recTrackContSecvtxMC", "Container for secondary vertexing analysis with MC information", 1);

  if(HasMCData()){
    fContainer->CreateContainer("conversionElecs", "Container for weighted conversion electrons",7);
    fContainer->CreateContainer("mesonElecs", "Container for weighted electrons from meson decays",7);
    fContainer->Sumw2("conversionElecs");
    fContainer->Sumw2("mesonElecs");
   
    if(fisNonHFEsystematics){
      const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};
      const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};
      for(Int_t iSource = 0; iSource < kElecBgSpecies; iSource++){
        for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
          fContainer->CreateContainer(Form("conversionElecs%s%s",sourceName[iSource],levelName[iLevel]), Form("Container for weighted conversion electrons from %s grandm., %s level",sourceName[iSource],levelName[iLevel]),5);
          fContainer->CreateContainer(Form("mesonElecs%s%s",sourceName[iSource],levelName[iLevel]), Form("Container for weighted electrons from %s decays, %s level",sourceName[iSource],levelName[iLevel]),5);
          fContainer->Sumw2(Form("conversionElecs%s%s",sourceName[iSource],levelName[iLevel]));
          fContainer->Sumw2(Form("mesonElecs%s%s",sourceName[iSource],levelName[iLevel]));
          if(IsPbPb())break;
        }
      }
    }
    //fContainer->CreateContainer("charmElecs", "Container for weighted charm electrons",2);
  }

  fContainer->CreateCorrelationMatrix("correlationstepafterPID","THnSparse with correlations");
  fContainer->CreateCorrelationMatrix("correlationstepafterDE","THnSparse with correlations");
  if(!fVarManager->IsVariableDefined("centrality")) {
    //printf("Create the two other correlation maps\n");
    fContainer->CreateCorrelationMatrix("correlationstepbeforePID","THnSparse with correlations");
    fContainer->CreateCorrelationMatrix("correlationstepafterTOF","THnSparse with correlations");
  }

  // Define the step names
  for(UInt_t istep = 0; istep < AliHFEcuts::kNcutStepsMCTrack; istep++){
    fContainer->SetStepTitle("MCTrackCont", AliHFEcuts::MCCutName(istep), istep);
  }
  for(UInt_t istep = 0; istep < AliHFEcuts::kNcutStepsRecTrack; istep++){
    fContainer->SetStepTitle("recTrackContReco", AliHFEcuts::RecoCutName(istep), istep);
    fContainer->SetStepTitle("recTrackContMC", AliHFEcuts::RecoCutName(istep), istep);
  }
  for(UInt_t ipid = 0; ipid < fPID->GetNumberOfPIDdetectors(); ipid++){
    fContainer->SetStepTitle("recTrackContReco", fPID->SortedDetectorName(ipid), AliHFEcuts::kNcutStepsRecTrack + ipid);
    fContainer->SetStepTitle("recTrackContMC", fPID->SortedDetectorName(ipid), AliHFEcuts::kNcutStepsRecTrack + ipid);
  }
}
//____________________________________________________________
void AliAnalysisTaskHFE::InitContaminationQA(){
  // 
  // Add QA for Impact Parameter cut
  //

  TObjArray *array = fVarManager->GetVariables();
  Int_t nvars = array->GetEntriesFast();
  for(Int_t v = 0; v < nvars; v++) {
    AliHFEvarManager::AliHFEvariable *variable = (AliHFEvarManager::AliHFEvariable *) array->At(v);
    if(!variable) continue;
    TString name(((AliHFEvarManager::AliHFEvariable *)variable)->GetName());
    if(!name.CompareTo("pt")) {
      const Int_t nBinPt  = variable->GetNumberOfBins();
      const Double_t *kPtRange = variable->GetBinning();

      fQACollection->CreateTH1Farray("hadronsBeforeIPcut", "Hadrons before IP cut", nBinPt, kPtRange);
      fQACollection->CreateTH1Farray("hadronsAfterIPcut", "Hadrons after IP cut", nBinPt, kPtRange);

      fQACollection->CreateTH2Farray("Ke3Kecorr", "Ke3 decay e and K correlation; Ke3K p_{t}; Ke3e p_{t}; ", nBinPt, kPtRange, 20,0.,20.);
      fQACollection->CreateTH2Farray("Ke3K0Lecorr", "Ke3 decay e and K0L correlation; Ke3K0L p_{t}; Ke3e p_{t}; ", nBinPt, kPtRange, 20,0.,20.);
      fQACollection->CreateTH1Farray("Kptspectra", "Charged Kaons: MC p_{t} ", nBinPt, kPtRange);
      fQACollection->CreateTH1Farray("K0Lptspectra", "K0L: MC p_{t} ", nBinPt, kPtRange);

      const Double_t kDCAbound[2] = {-0.2, 0.2};

      const Int_t nDimDca=6;
      const Int_t nBinDca[nDimDca] = { 8, nBinPt, 800, 12,  6, 2};
      Double_t minimaDca[nDimDca]  = { -1., 0., kDCAbound[0], -1., -1, -1.1};
      Double_t maximaDca[nDimDca]  = { 7., 20., kDCAbound[1], 11.,  5, 1.1};

      Double_t *sourceBins = AliHFEtools::MakeLinearBinning(nBinDca[0], minimaDca[0], maximaDca[0]);
      Double_t *dcaBins = AliHFEtools::MakeLinearBinning(nBinDca[2], minimaDca[2], maximaDca[2]);
      Double_t *centralityBins = AliHFEtools::MakeLinearBinning(nBinDca[3], minimaDca[3], maximaDca[3]);
      Double_t *v0PIDBins = AliHFEtools::MakeLinearBinning(nBinDca[4], minimaDca[4], maximaDca[4]);
      Double_t *chargeBins = AliHFEtools::MakeLinearBinning(nBinDca[5], minimaDca[5], maximaDca[5]);

      fQACollection->CreateTHnSparseNoLimits("Dca", "Dca; source (0-all, 1-charm,etc); pT [GeV/c]; dca; centrality bin; v0pid; charge", nDimDca, nBinDca);
      ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(0, sourceBins);
      ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(1, kPtRange);
      ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(2, dcaBins);
      ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(3, centralityBins);
      ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(4, v0PIDBins);
      ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(5, chargeBins);

      break;
    }  
  }

}
//____________________________________________________________
void AliAnalysisTaskHFE::InitHistoRadius(){
  //
  
  // Before   
  const Int_t kNDim = 3;
  const Int_t kNBins[kNDim] = {11, 35, 25};
  const Double_t kMin[kNDim] = {0,0.1,0.01};
  const Double_t kMax[kNDim] = {11,20.,25.};
  fQACollection->CreateTHnSparse("RadiusBefore", "RadiusBefore; centrality; p_{T} (GeV/c);radius [cm]", kNDim, kNBins, kMin, kMax);
  fQACollection->BinLogAxis("RadiusBefore", 1);
  fQACollection->BinLogAxis("RadiusBefore", 2);

  // After
  fQACollection->CreateTHnSparse("RadiusAfter", "RadiusAfter; centrality; p_{T} (GeV/c);radius [cm]", kNDim, kNBins, kMin, kMax);
  fQACollection->BinLogAxis("RadiusAfter", 1);
  fQACollection->BinLogAxis("RadiusAfter", 2);


}

//____________________________________________________________
void AliAnalysisTaskHFE::InitHistoITScluster(){
  //
    // Initialize a temporary histogram to monitor the chi2/ITS cluster
    if(IsPbPb()) {
        const Int_t kNDim = 7;
        const Int_t kNBins[kNDim] = {88, 20,90,11, 160, 2, 1000};
        const Double_t kMin[kNDim] = {0.1, -1,0,  0.,0., 0,  0.};
        const Double_t kMax[kNDim] = {20., 1, 2.*TMath::Pi(), 11.,160, 2, 100.};
        fQACollection->CreateTHnSparse("fChi2perITScluster", "chi2/ITS cluster; p_{T} (GeV/c);eta;phi; centrality class;nclus;sharebit; #chi^{2}/ITS cluster", kNDim, kNBins, kMin, kMax);
        fQACollection->BinLogAxis("fChi2perITScluster", 0);
    }
    else
    {
        const Int_t kNDim = 3;
        const Int_t kNBins[kNDim] = {44, 11, 1000};
        const Double_t kMin[kNDim] = {0.1, 0., 0.};
        const Double_t kMax[kNDim] = {20., 11., 100.};
        fQACollection->CreateTHnSparse("fChi2perITScluster", "chi2/ITS cluster; p_{T} (GeV/c); centrality class; #chi^{2}/ITS cluster", kNDim, kNBins, kMin, kMax);
        fQACollection->BinLogAxis("fChi2perITScluster", 0);
    }
}

//____________________________________________________________
void AliAnalysisTaskHFE::SelectSpecialTrigger(const Char_t *trgclust, Int_t runMin, Int_t runMax){
  //
  // Select only events triggered by a special trigeer cluster
  //
  if(!fSpecialTrigger) fSpecialTrigger = new AliOADBContainer("SpecialTrigger");
  fSpecialTrigger->AppendObject(new TObjString(trgclust), runMin, runMax);
}

//____________________________________________________________
const Char_t * AliAnalysisTaskHFE::GetSpecialTrigger(Int_t run){
  //
  // Derive selected trigger string for given run
  //
  if(!fSpecialTrigger) return NULL;
  TObjString *trg = dynamic_cast<TObjString *>(fSpecialTrigger->GetObject(run));
  if(!trg) return NULL;
  return trg->String().Data();
}

//____________________________________________________________
void AliAnalysisTaskHFE::PrintStatus() const {
  //
  // Print Analysis status
  //
  printf("\n\tAnalysis Settings\n\t========================================\n\n");
  printf("\tSecondary Vertex finding: %s\n", GetPlugin(kSecVtx) ? "YES" : "NO");
  printf("\tPrimary Vertex resolution: %s\n", GetPlugin(kPriVtx) ? "YES" : "NO");
  printf("\tDisplaced electron analysis step: %s\n", GetPlugin(kDEstep) ? "YES" : "NO");
  printf("\tTagged Track Analysis: %s\n", GetPlugin(kTaggedTrackAnalysis) ? "YES" : "NO");
  printf("\n");
  printf("\tParticle Identification Detectors:\n");
  fPID->PrintStatus();
  printf("\n");
  printf("\tQA: \n");
  printf("\t\tPID: %s\n", IsQAOn(kPIDqa) ? "YES" :  "NO");
  printf("\t\tCUTS: %s\n", (fCuts != NULL && fCuts->IsQAOn()) ? "YES" : "NO");
  printf("\t\tMC: %s\n", IsQAOn(kMCqa) ? "YES" : "NO");
  printf("\n");
}

//____________________________________________________________
Bool_t AliAnalysisTaskHFE::FillProductionVertex(const AliVParticle * const track) const{
  //
  // Find the production vertex of the associated MC track
  //
  if(!fMCEvent) return kFALSE;
  const AliVParticle *mctrack = NULL;
  TString objectType = track->IsA()->GetName();
  if(objectType.CompareTo("AliESDtrack") == 0 || objectType.CompareTo("AliAODTrack") == 0){
    // Reconstructed track
    mctrack = fMCEvent->GetTrack(TMath::Abs(track->GetLabel()));
  } else {
    // MCParticle
    mctrack = track;
  }

  if(!mctrack) return kFALSE;

  Double_t xv = 0.0;
  Double_t yv = 0.0;
 
  if(TString(mctrack->IsA()->GetName()).CompareTo("AliMCParticle") == 0){
    // case MCParticle
    const AliMCParticle *mcpart = dynamic_cast<const AliMCParticle *>(mctrack);
    if(mcpart){
      xv =  mcpart->Xv();
      yv =  mcpart->Yv();
    }
  } else {
    // case AODMCParticle
    const AliAODMCParticle *mcpart = dynamic_cast<const AliAODMCParticle *>(mctrack);
    if(mcpart){
      xv =  mcpart->Xv();
      yv =  mcpart->Yv();
    }
  }

  //printf("xv %f, yv %f\n",xv,yv);
  fQACollection->Fill("radius", TMath::Abs(xv),TMath::Abs(yv));

  return kTRUE;

}
//__________________________________________
void AliAnalysisTaskHFE::SwitchOnPlugin(Int_t plug){
  //
  // Switch on Plugin
  // Available:
  //  - Primary vertex studies
  //  - Secondary vertex Studies
  //  - Post Processing
  //
  switch(plug){
    case kPriVtx: SETBIT(fPlugins, plug); break;
    case kSecVtx: SETBIT(fPlugins, plug); break;
    case kIsElecBackGround: SETBIT(fPlugins, plug); break;
    case kPostProcess: SETBIT(fPlugins, plug); break;
    case kDEstep: SETBIT(fPlugins, plug); break;
    case kTaggedTrackAnalysis: SETBIT(fPlugins, plug); break;
    case kNonPhotonicElectron: SETBIT(fPlugins, plug); break; 
    case kNonPhotonicElectronBeauty: SETBIT(fPlugins, plug); break; 
    default: AliError("Unknown Plugin");
  };
}
//__________________________________________
Bool_t AliAnalysisTaskHFE::ProcessCutStep(Int_t cutStep, AliVParticle *track){
  //
  // Check single track cuts for a given cut step
  // Fill the particle container
  //
  const Int_t kMCOffset = AliHFEcuts::kNcutStepsMCTrack;
  if(!fCFM->CheckParticleCuts(cutStep + kMCOffset, track)) return kFALSE;
  if(fVarManager->IsSignalTrack()) {
    fVarManager->FillContainer(fContainer, "recTrackContReco", cutStep, kFALSE);
    fVarManager->FillContainer(fContainer, "recTrackContMC", cutStep, kTRUE);
  }
  return kTRUE;
}
//___________________________________________________
Bool_t AliAnalysisTaskHFE::ReadCentrality() {
  //
  // Recover the centrality of the event from ESD or AOD
  //
  
  Float_t fCentralityLimitstemp[12];
  Float_t fCentralityLimitsdefault[12]= {0.,5.,10., 20., 30., 40., 50., 60.,70.,80., 90., 100.00001};
  if(!fPbPbUserCentralityBinning) memcpy(fCentralityLimitstemp,fCentralityLimitsdefault,sizeof(fCentralityLimitsdefault));
  else memcpy(fCentralityLimitstemp,fCentralityLimits,sizeof(fCentralityLimitsdefault));
  

  Int_t bin = -1;
  if(IsPbPb()||IspPb()) {
    // Centrality
    AliCentrality *centrality = fInputEvent->GetCentrality();
    fCentralityPercent = centrality->GetCentralityPercentile(fCentralityEstimator.Data());
    //printf("centrality %f\n",fCentralityPercent);

    for(Int_t ibin = 0; ibin < 11; ibin++){
      if(fCentralityPercent >= fCentralityLimitstemp[ibin] && fCentralityPercent < fCentralityLimitstemp[ibin+1]){
        bin = ibin;
	//printf("test bin %f, low %f, high %f, %d\n",fCentralityPercent,fCentralityLimitstemp[ibin],fCentralityLimitstemp[ibin+1],ibin);
        break;
      }
    }
    
    if(bin == -1) bin = 11; // Overflow
  } else {
    // PP: Tracklet multiplicity, use common definition
    Int_t itsMultiplicity = GetITSMultiplicity(fInputEvent);
    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;
      }
    }
    if(bin == -1) bin = 7;  // Overflow
  }
  fCentralityF = bin;
  AliDebug(2, Form("Centrality class %d\n", fCentralityF));

 
  // contributors, to be outsourced
  const AliVVertex *vtx;
  if(IsAODanalysis()){
    AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);
    if(!fAOD){
      AliError("AOD Event required for AOD Analysis");
      return kFALSE;
    }
    vtx = fAOD->GetPrimaryVertex();
  } else {
    AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);
    if(!fESD){
      AliError("ESD Event required for ESD Analysis");
      return kFALSE;
    }
    vtx = fESD->GetPrimaryVertex() ;
  }
  if(!vtx){ 
    fContributors = 0.5;
    return kFALSE;
  }
  else {
    Int_t contributorstemp = vtx->GetNContributors();
    if( contributorstemp <=  0) {
      fContributors =  0.5;
      //printf("Number of contributors %d and vz %f\n",contributorstemp,vtx->GetZ());
    }
    else fContributors = 1.5;
    //printf("Number of contributors %d\n",contributorstemp);
  }
  return kTRUE;
}

//___________________________________________________
Int_t AliAnalysisTaskHFE::GetITSMultiplicity(AliVEvent *ev){
  //
  // Definition of the Multiplicity according to the JPSI group (F. Kramer)
  //
  Int_t nTracklets = 0;
  Int_t nAcc = 0;
  Double_t etaRange = 1.6;

  if (ev->IsA() == AliAODEvent::Class()) {
    AliAODTracklets *tracklets = ((AliAODEvent*)ev)->GetTracklets();
    nTracklets = tracklets->GetNumberOfTracklets();
    for (Int_t nn = 0; nn < nTracklets; nn++) {
      Double_t theta = tracklets->GetTheta(nn);
      Double_t eta = -TMath::Log(TMath::Tan(theta/2.0));
      if (TMath::Abs(eta) < etaRange) nAcc++;
    }
  } else if (ev->IsA() == AliESDEvent::Class()) {
    nTracklets = ((AliESDEvent*)ev)->GetMultiplicity()->GetNumberOfTracklets();
    for (Int_t nn = 0; nn < nTracklets; nn++) {
       Double_t eta = ((AliESDEvent*)ev)->GetMultiplicity()->GetEta(nn);
      if (TMath::Abs(eta) < etaRange) nAcc++;
    }
  } else return -1;

  return nAcc;
}

//___________________________________________________
void AliAnalysisTaskHFE::RejectionPileUpVertexRangeEventCut() {
  //
  // Recover the centrality of the event from ESD or AOD
  //
 if(IsAODanalysis()){

   AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);
   if(!fAOD){
     AliError("AOD Event required for AOD Analysis");
       return;
   }
   // PileUp
   fIdentifiedAsPileUp = kFALSE;
   if(fRemovePileUp && fAOD->IsPileupFromSPD()) fIdentifiedAsPileUp = kTRUE; 
   // Z vertex
   fIdentifiedAsOutInz = kFALSE;
   //printf("Z vertex %f and out %f\n",fAOD->GetPrimaryVertex()->GetZ(),fCuts->GetVertexRange());
   if(TMath::Abs(fAOD->GetPrimaryVertex()->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE;
   // Event Cut
   fPassTheEventCut = kTRUE;
   if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fAOD)) fPassTheEventCut = kFALSE; 
   
   
 } else {
   
   AliDebug(3, "Processing ESD Centrality");
   AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);
   if(!fESD){
     AliError("ESD Event required for ESD Analysis");
       return;
   }
   // PileUp
   fIdentifiedAsPileUp = kFALSE;
   if(fRemovePileUp && fESD->IsPileupFromSPD()) fIdentifiedAsPileUp = kTRUE; 
   


   // Z vertex
   fIdentifiedAsOutInz = kFALSE;
   Bool_t findvertex = kTRUE;
   const AliESDVertex* vtxESD = fESD->GetPrimaryVertex();
   if((!vtxESD) || (vtxESD->GetNContributors() <= 0)) findvertex = kFALSE;
   if(findvertex) {
     if(TMath::Abs(vtxESD->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE;
   }
   
   //Event Cut
   fPassTheEventCut = kTRUE;
   if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fESD)) fPassTheEventCut = kFALSE;   
  
 }

}

//___________________________________________________
Bool_t AliAnalysisTaskHFE::CheckTRDTriggerESD(AliESDEvent *ev) {
//
// Check TRD trigger; pPb settings
//
    Bool_t cint8=kFALSE;
    Bool_t cint7=kFALSE;
    Bool_t cint5=kFALSE;
    Bool_t cint8s=kFALSE;
    Bool_t cint7s=kFALSE;
    Bool_t cint7ppb=kFALSE;
    Bool_t trdtrgevent=kFALSE;

  //  printf("TRIGGERS %s \n",ev->GetFiredTriggerClasses().Data());

    if(fWhichTRDTrigger==4) fTRDTriggerAnalysistrg->CalcTriggers(ev);
    else fTRDTriggerAnalysismb->CalcTriggers(ev);


    // mb selection of WU events
    if(fWhichTRDTrigger==1)
    {
//	if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))
	if((ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))||(ev->IsTriggerClassFired("CINT7WU-S-NOPF-ALL"))||(ev->IsTriggerClassFired("CINT8WU-S-NOPF-ALL")))
	{
	    DrawTRDTrigger(ev);
	    DrawTRDTriggerAnalysis(ev);
	    return kTRUE;
	}
        else return kFALSE;
    }


    // HSE no cleanup
    if(fWhichTRDTrigger==2)
    {
	cint8= ev->IsTriggerClassFired("CINT8WUHSE-B-NOPF-CENT");
	cint7= ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT");  // pPb rare
	cint7ppb= ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-ALL"); // pPb mb
	cint8s= ev->IsTriggerClassFired("CINT7WUHSE-S-NOPF-CENT");
	cint7s= ev->IsTriggerClassFired("CINT8WUHSE-S-NOPF-CENT");
	cint5= (ev->IsTriggerClassFired("CINT5WU-B-NOPF-ALL")) &&
	    (ev->GetHeader()->GetL1TriggerInputs() & (1 << 10));
//        printf("hse trigger %i %i %i %i %i \n",cint7,cint7ppb,cint8,cint7s,cint8s);
	if((cint7==kFALSE)&&(cint7ppb==kFALSE)&&(cint8==kFALSE)&&(cint7s==kFALSE)&&(cint8s==kFALSE)&&(cint5==kFALSE)) return kFALSE;
	else
	{
	    DrawTRDTrigger(ev);
	    DrawTRDTriggerAnalysis(ev);
	    return kTRUE;
	}
    }

   

    //HQU no cleanup
    if(fWhichTRDTrigger==3)
    {
	cint8= ev->IsTriggerClassFired("CINT8WUHQU-B-NOPF-CENT");
	cint7= ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT");    // pPb rare
	cint7ppb= ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-ALL"); // pPb mb
	cint8s= ev->IsTriggerClassFired("CINT7WUHQU-S-NOPF-CENT");
	cint7s= ev->IsTriggerClassFired("CINT8WUHQU-S-NOPF-CENT");
	cint5= (ev->IsTriggerClassFired("CINT5WU-B-NOPF-ALL")) &&
	    (ev->GetHeader()->GetL1TriggerInputs() & (1 << 12));
 //       printf("hqu trigger %i %i %i %i %i \n",cint7,cint7ppb,cint8,cint7s,cint8s);
	if((cint7==kFALSE)&&(cint7ppb==kFALSE)&&(cint8==kFALSE)&&(cint7s==kFALSE)&&(cint8s==kFALSE)&&(cint5==kFALSE)) return kFALSE;
	else
	{
	    DrawTRDTrigger(ev);
	    DrawTRDTriggerAnalysis(ev);
	    return kTRUE;
	}
    }

    if(fWhichTRDTrigger==4)
    {
//	printf("trigger %i %i \n", ev->GetHeader()->IsTriggerInputFired("1HSE"),(ev->GetHeader()->GetL1TriggerInputs() & (1 << 10))); // bug in IsTriggerInputFired; reported in savannah

//	if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))
//	{
//	    Int_t trginput=0;
//	    trginput=ev->GetHeader()->GetL1TriggerInputs() & (1 << 10);  // HSE
	    //	    if(trginput==1024)
//	    if(fTRDTriggerAnalysismb->CheckCondition(AliTRDTriggerAnalysis::kHSE))
	//	    if(fTRDTriggerAnalysismb->HasTriggered(AliTRDTriggerAnalysis::kHSE))

//	if(fTRDTriggerAnalysismb->HasFired(AliTRDTriggerAnalysis::kHSE)) // for mb analysis
	if(fTRDTriggerAnalysistrg->HasFired(AliTRDTriggerAnalysis::kHSE)) // just to check clean-up effect
	{
            // check if pre-trigger fired
	    if((ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))||(ev->IsTriggerClassFired("CINT7WU-S-NOPF-ALL"))||(ev->IsTriggerClassFired("CINT8WU-S-NOPF-ALL")))
	    {
		DrawTRDTrigger(ev);
		DrawTRDTriggerAnalysis(ev);
		return kTRUE;
	    } else return kFALSE;
	}
    }// else return kFALSE;
//    }
    if(fWhichTRDTrigger==5)
    {
//	printf("trigger %i %i \n", ev->GetHeader()->IsTriggerInputFired("1HQU"),(ev->GetHeader()->GetL1TriggerInputs() & (1 << 12))); // bug in IsTriggerInputFired; reported in savannah
//	if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))
//	{

//	    Int_t trginput=0;
//	    trginput=ev->GetHeader()->GetL1TriggerInputs() & (1 << 12);  //HQU
	    //        printf("triggerinput %i \n",trginput);
	    //	    if(trginput==4096)
//	    if(fTRDTriggerAnalysismb->CheckCondition(AliTRDTriggerAnalysis::kHQU))
//	if(fTRDTriggerAnalysismb->HasTriggered(AliTRDTriggerAnalysis::kHQU))
        if(fTRDTriggerAnalysismb->HasFired(AliTRDTriggerAnalysis::kHQU)) // for mb analysis
	    {
		// check if pre-trigger fired
		if((ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))||(ev->IsTriggerClassFired("CINT7WU-S-NOPF-ALL"))||(ev->IsTriggerClassFired("CINT8WU-S-NOPF-ALL")))
		{
		    DrawTRDTrigger(ev);
		    DrawTRDTriggerAnalysis(ev);
		    return kTRUE;
		} else return kFALSE;
	    }
    } //else return kFALSE;
//    }

  




    return trdtrgevent;

}


//___________________________________________________
Bool_t AliAnalysisTaskHFE::CheckTRDTrigger(AliVEvent *ev) {
//
// Check TRD trigger; pPb settings
//

    if(fWhichTRDTrigger<10) fTRDTriggerAnalysistrg->CalcTriggers(ev);
    else fTRDTriggerAnalysismb->CalcTriggers(ev);

    // HSE cleanup
    if(fWhichTRDTrigger==6)
    {
	if(fTRDTriggerAnalysistrg->HasTriggeredConfirmed(AliTRDTriggerAnalysis::kHSE)) // for rare period physics analysis
	{
	    //   DrawTRDTrigger(ev);
	    DrawTRDTriggerAnalysis(ev);
	    return kTRUE;
	} else return kFALSE;
    }

 

    // HQU cleanup
    if(fWhichTRDTrigger==7)
    {

	if(fTRDTriggerAnalysistrg->HasTriggeredConfirmed(AliTRDTriggerAnalysis::kHQU)) // for rare period physics analysis
	{
	    //     DrawTRDTrigger(ev);
	    DrawTRDTriggerAnalysis(ev);
	    return kTRUE;
	} else return kFALSE;
    }

    // HSE or HQU cleanup
    if(fWhichTRDTrigger==8)
    {
	if((fTRDTriggerAnalysistrg->HasTriggeredConfirmed(AliTRDTriggerAnalysis::kHSE))||(fTRDTriggerAnalysistrg->HasTriggeredConfirmed(AliTRDTriggerAnalysis::kHQU)))
	{
	    //    DrawTRDTrigger(ev);
	    DrawTRDTriggerAnalysis(ev);
	    return kTRUE;
	}
	else
	{
	    return kFALSE; 
	}
    }

    // HEE cleanup
    if(fWhichTRDTrigger==9)
    {

	if(fTRDTriggerAnalysistrg->HasTriggeredConfirmed(AliTRDTriggerAnalysis::kHEE)) // for rare period physics analysis
	{
	    //     DrawTRDTrigger(ev);
	    DrawTRDTriggerAnalysis(ev);
	    return kTRUE;
	} else return kFALSE;
    }


    if(fWhichTRDTrigger==11)
    {
	if(fTRDTriggerAnalysismb->HasTriggered(AliTRDTriggerAnalysis::kHSE))
	{
	  //  DrawTRDTrigger(ev);
	    DrawTRDTriggerAnalysis(ev);
	    return kTRUE;
	}   else return kFALSE;
    }
    if(fWhichTRDTrigger==12)
    {
	if(fTRDTriggerAnalysismb->HasTriggered(AliTRDTriggerAnalysis::kHQU))
	{
	  //  DrawTRDTrigger(ev);
	    DrawTRDTriggerAnalysis(ev);
	    return kTRUE;
	}   else return kFALSE;
    }
    if(fWhichTRDTrigger==13)
    {
	if(fTRDTriggerAnalysismb->HasTriggered(AliTRDTriggerAnalysis::kHEE))
	{
	  //  DrawTRDTrigger(ev);
	    DrawTRDTriggerAnalysis(ev);
	    return kTRUE;
	}   else return kFALSE;
    }

    return kFALSE;

}

//___________________________________________________
void AliAnalysisTaskHFE::DrawTRDTrigger(AliESDEvent *ev) {

    Int_t ntriggerbit=0;
    fQACollection->Fill("nTriggerBit",ntriggerbit);
    if(ev->IsTriggerClassFired("CINT7-B-NOPF-ALLNOTRD"))
    {
	ntriggerbit=2;
	fQACollection->Fill("nTriggerBit",ntriggerbit);
    }
    if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))
    {
	ntriggerbit=3;
	fQACollection->Fill("nTriggerBit",ntriggerbit);
	if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
	    ntriggerbit=18;
	    fQACollection->Fill("nTriggerBit",ntriggerbit);
	}
	if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")) {
	    ntriggerbit=19;
	    fQACollection->Fill("nTriggerBit",ntriggerbit);
	}
    }
    if(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-CENT"))
    {
	ntriggerbit=4;
	fQACollection->Fill("nTriggerBit",ntriggerbit);

	if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
	    ntriggerbit=13;
	    fQACollection->Fill("nTriggerBit",ntriggerbit);
	}
	if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")) {
	    ntriggerbit=14;
	    fQACollection->Fill("nTriggerBit",ntriggerbit);
	    if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
		ntriggerbit=17;
		fQACollection->Fill("nTriggerBit",ntriggerbit);
	    }
	}
    }
    if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT"))
    {
	ntriggerbit=5;
	fQACollection->Fill("nTriggerBit",ntriggerbit);
	if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
	    ntriggerbit=11;
	    fQACollection->Fill("nTriggerBit",ntriggerbit);
	}
	if((!(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")))&&(!(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-CENT")))) {
	    ntriggerbit=21;
	    fQACollection->Fill("nTriggerBit",ntriggerbit);

            /*
	    Int_t nTrdTracks = ev->GetNumberOfTrdTracks();
	    for (Int_t iTrack = 0; iTrack < nTrdTracks; ++iTrack) {
		AliESDTrdTrack* trdTrack = ev->GetTrdTrack(iTrack);
		printf("GTU track %3i: pt = %5.1f, PID = %3i\n", iTrack, trdTrack->Pt(), trdTrack->GetPID());
	    }*/


	}

    }
    if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT"))
    {
	ntriggerbit=6;
	fQACollection->Fill("nTriggerBit",ntriggerbit);
	if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")) {
	    ntriggerbit=12;
	    fQACollection->Fill("nTriggerBit",ntriggerbit);
	}
	if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-FAST")){
	    ntriggerbit=15;
	    fQACollection->Fill("nTriggerBit",ntriggerbit);

	    if((!(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")))&&(!(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-CENT")))) {
		ntriggerbit=20;
		fQACollection->Fill("nTriggerBit",ntriggerbit);
		/*
		 Int_t nTrdTracks = ev->GetNumberOfTrdTracks();
		 for (Int_t iTrack = 0; iTrack < nTrdTracks; ++iTrack) {
		 AliESDTrdTrack* trdTrack = ev->GetTrdTrack(iTrack);
		 printf("HSE GTU track %3i: pt = %5.1f, PID = %3i\n", iTrack, trdTrack->Pt(), trdTrack->GetPID());
		 }                          */

	    }

	}

    }
    if(ev->IsTriggerClassFired("CEMC7WUHEE-B-NOPF-CENT")) {
	ntriggerbit=7;
	fQACollection->Fill("nTriggerBit",ntriggerbit);
    }
    if(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-FAST")){
	ntriggerbit=8;
	fQACollection->Fill("nTriggerBit",ntriggerbit);
    }
    if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-FAST")){
	ntriggerbit=9;
	fQACollection->Fill("nTriggerBit",ntriggerbit);
    }
    if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-FAST")){
	ntriggerbit=10;
	fQACollection->Fill("nTriggerBit",ntriggerbit);
	if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
	    ntriggerbit=16;
	    fQACollection->Fill("nTriggerBit",ntriggerbit);
	}
    }
    if(ntriggerbit==0) fQACollection->Fill("nTriggerBit",1);

}


//___________________________________________________
void AliAnalysisTaskHFE::DrawTRDTriggerAnalysis(AliVEvent *ev) {

    fTRDTriggerAnalysistrg->CalcTriggers(ev);
    for(Int_t itrg=0;itrg<AliTRDTriggerAnalysis::kHlast;itrg++)
    {
        Int_t trdtrgstatus=0;
	if(fTRDTriggerAnalysistrg->CheckCondition((AliTRDTriggerAnalysis::TRDTrigger_t) itrg))trdtrgstatus=1;
	if(fTRDTriggerAnalysistrg->HasFired((AliTRDTriggerAnalysis::TRDTrigger_t) itrg))trdtrgstatus=2;
	if(fTRDTriggerAnalysistrg->HasTriggered((AliTRDTriggerAnalysis::TRDTrigger_t) itrg))trdtrgstatus=3;
	if(fTRDTriggerAnalysistrg->HasTriggeredConfirmed((AliTRDTriggerAnalysis::TRDTrigger_t) itrg))trdtrgstatus=4;
        fQACollection->Fill("TriggerAnalysis",(Float_t)itrg,(Float_t)trdtrgstatus);
    }
}

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