Update hfe package
authorrbailhac <rbailhac@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 11 Sep 2012 16:50:16 +0000 (16:50 +0000)
committerrbailhac <rbailhac@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 11 Sep 2012 16:50:16 +0000 (16:50 +0000)
28 files changed:
PWGHF/CMakelibPWGHFhfe.pkg
PWGHF/PWGHFhfeLinkDef.h
PWGHF/hfe/AliAnalysisTaskDCA.cxx [deleted file]
PWGHF/hfe/AliAnalysisTaskDCA.h [deleted file]
PWGHF/hfe/AliAnalysisTaskDisplacedElectrons.cxx [deleted file]
PWGHF/hfe/AliAnalysisTaskDisplacedElectrons.h [deleted file]
PWGHF/hfe/AliAnalysisTaskHFEFlowData.cxx [deleted file]
PWGHF/hfe/AliAnalysisTaskHFEFlowData.h [deleted file]
PWGHF/hfe/AliHFEcuts.cxx
PWGHF/hfe/AliHFEcuts.h
PWGHF/hfe/AliHFEdca.cxx [deleted file]
PWGHF/hfe/AliHFEdca.h [deleted file]
PWGHF/hfe/AliHFEdebugTreeTask.cxx
PWGHF/hfe/AliHFEdebugTreeTask.h
PWGHF/hfe/AliHFEdisplacedElectrons.cxx [deleted file]
PWGHF/hfe/AliHFEdisplacedElectrons.h [deleted file]
PWGHF/hfe/AliHFEextraCuts.cxx
PWGHF/hfe/AliHFEextraCuts.h
PWGHF/hfe/AliHFEmcQA.cxx
PWGHF/hfe/AliHFEmcQA.h
PWGHF/hfe/AliHFEpidTPC.cxx
PWGHF/hfe/AliHFEpidTPC.h
PWGHF/hfe/AliHFEspectrum.cxx
PWGHF/hfe/AliHFEspectrum.h
PWGHF/hfe/AliHFEtofPIDqa.cxx
PWGHF/hfe/AliHFEtofPIDqa.h
PWGHF/hfe/AliHFEtools.cxx
PWGHF/hfe/AliHFEtools.h

index 03662ae..71013cf 100644 (file)
@@ -63,11 +63,7 @@ set (SRCS
     hfe/AliHFEsignalCuts.cxx 
     hfe/AliHFEelecbackground.cxx 
     hfe/AliHFEtaggedTrackAnalysis.cxx 
-    hfe/AliHFEdca.cxx 
-    hfe/AliAnalysisTaskDCA.cxx 
-    hfe/AliHFEdisplacedElectrons.cxx 
     hfe/AliHFEpostAnalysis.cxx 
-    hfe/AliAnalysisTaskDisplacedElectrons.cxx 
     hfe/AliAnalysisTaskHFEpidQA.cxx 
     hfe/AliHFEefficiency.cxx 
     hfe/AliAnalysisTaskHFE.cxx 
@@ -83,7 +79,6 @@ set (SRCS
     hfe/AliHFEdebugTreeTask.cxx
     hfe/AliHFEVZEROEventPlane.cxx
     hfe/AliAnalysisTaskHFEFlow.cxx
-    hfe/AliAnalysisTaskHFEFlowData.cxx
     hfe/AliSelectNonHFE.cxx
     )
 
index ac45ece..7973ead 100644 (file)
 #pragma link C++ class  AliHFEextraEventCuts+;
 #pragma link C++ class  AliHFEsignalCuts+;
 
-#pragma link C++ class  AliHFEdca+;
-#pragma link C++ class  AliAnalysisTaskDCA+;
-
 #pragma link C++ class  AliHFEpostAnalysis+;
 #pragma link C++ class  AliAnalysisTaskHFE+;
 #pragma link C++ class  AliAnalysisTaskHFEpidQA+;
 #pragma link C++ class  AliHFEefficiency+;
 
-#pragma link C++ class  AliHFEdisplacedElectrons+;
-#pragma link C++ class  AliAnalysisTaskDisplacedElectrons+;
-
 #pragma link C++ class  AliHFEOADBThresholdsTRD+;
 #pragma link C++ class  AliHFEOADBThresholdsTRD::AliHFEthresholdParamsTRD+;
 #pragma link C++ class  AliHFEbayesPIDqa+;
@@ -75,7 +69,6 @@
 
 #pragma link C++ class  AliHFEVZEROEventPlane+;
 #pragma link C++ class  AliAnalysisTaskHFEFlow+;
-#pragma link C++ class  AliAnalysisTaskHFEFlowData+;
 
 #pragma link C++ class  AliSelectNonHFE+;
 
diff --git a/PWGHF/hfe/AliAnalysisTaskDCA.cxx b/PWGHF/hfe/AliAnalysisTaskDCA.cxx
deleted file mode 100644 (file)
index cfd2db7..0000000
+++ /dev/null
@@ -1,770 +0,0 @@
-/**************************************************************************
-* 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:
-// impact parameter resolution and pull study
-// for tracks which survivied the particle cuts
-// 
-// 
-// Authors:
-//  Hongyan Yang <hongyan@physi.uni-heidelberg.de>
-//  Carlo Bombonati <carlo.bombonati@cern.ch>
-//
-#include <Riostream.h>
-#include <TChain.h>
-#include <TFile.h>
-#include <TH1F.h>
-#include <TH1I.h>
-#include <TList.h>
-#include <TMath.h>
-#include <TObjArray.h>
-#include <TParticle.h>
-#include <TString.h>
-
-#include <TCanvas.h>
-
-#include "AliAnalysisManager.h"
-
-#include "AliCFManager.h"
-
-#include "AliAODEvent.h"
-#include "AliESDInputHandler.h"
-#include "AliESDtrack.h"
-#include "AliVertexerTracks.h"
-#include "AliESDVertex.h"
-
-#include "AliMCEventHandler.h"
-#include "AliMCEvent.h"
-#include "AliMCParticle.h"
-#include "AliPIDResponse.h"
-
-#include "AliHFEpid.h"
-#include "AliHFEcuts.h"
-#include "AliHFEdca.h"
-#include "AliHFEtools.h"
-
-#include "AliAnalysisTaskDCA.h"
-
-using std::cout;
-using std::endl;
-
-ClassImp(AliAnalysisTaskDCA)
-//____________________________________________________________
-AliAnalysisTaskDCA::AliAnalysisTaskDCA():
-  AliAnalysisTaskSE("Impact Parameter Resolution and Pull Analysis")
-  , fPlugins(0)
-  , fCuts(0x0)
-  , fHFEpid(0x0)
-  , fPIDdetectors("")
-  , fPIDstrategy(0)
-  , fCFM(0x0)
-  , fDCA(0x0)
-  , fNclustersITS(0x0)
-  , fMinNprimVtxContrbutor(0x0)
-  , fNEvents(0x0)
-  , fResidualList(0x0)
-  , fPullList(0x0)
-  , fDcaList(0x0)
-  , fKfDcaList(0x0)
-  , fMcVertexList(0x0)
-  , fDataDcaList(0x0)
-  , fDataVertexList(0x0)
-  , fDataPullList(0x0)
-  , fMcPidList(0x0) 
-  , fDataPidList(0x0)
-  , fHfeDcaList(0x0)
-  , fHfeDataDcaList(0x0)
-  , fOutput(0x0)
-{
-  //
-  // Dummy constructor
-  //
-}
-
-//____________________________________________________________
-AliAnalysisTaskDCA::AliAnalysisTaskDCA(const char * name):
-  AliAnalysisTaskSE(name)
-  , fPlugins(0)
-  , fCuts(0x0)
-  , fHFEpid(0x0)
-  , fPIDdetectors("")
-  , fPIDstrategy(0)
-  , fCFM(0x0)
-  , fDCA(0x0)
-  , fNclustersITS(0x0)
-  , fMinNprimVtxContrbutor(0x0)
-  , fNEvents(0x0)
-  , fResidualList(0x0)
-  , fPullList(0x0)
-  , fDcaList(0x0) 
-  , fKfDcaList(0x0)
-  , fMcVertexList(0x0)
-  , fDataDcaList(0x0)
-  , fDataVertexList(0x0)
-  , fDataPullList(0x0)
-  , fMcPidList(0x0)
-  , fDataPidList(0x0)
-  , fHfeDcaList(0x0)
-  , fHfeDataDcaList(0x0)
-  , fOutput(0x0)
-{
-  //
-  // Default constructor
-  //
-  DefineInput(0, TChain::Class());
-  DefineOutput(1, TH1I::Class());
-  DefineOutput(2, TList::Class());
-
-
-  //-CUTS SETTING-//
-  Int_t nMinTPCcluster = 100;
-  Float_t maxDcaXY = 0.5;
-  Float_t maxDcaZ = 1.0;
-  //--------------//
-  AliHFEcuts *hfecuts = new AliHFEcuts;
-  hfecuts->CreateStandardCuts();
-  hfecuts->SetMinNClustersTPC(nMinTPCcluster);
-  hfecuts->SetCutITSpixel(AliHFEextraCuts::kFirst);
-  hfecuts->SetCheckITSLayerStatus(kFALSE);
-  hfecuts->SetMaxImpactParam(maxDcaXY, maxDcaZ);
-  SetHFECuts(hfecuts);
-  fHFEpid = new AliHFEpid("PIDforDCAanalysis");
-
-}
-
-//____________________________________________________________
-AliAnalysisTaskDCA::AliAnalysisTaskDCA(const AliAnalysisTaskDCA &ref):
-  AliAnalysisTaskSE(ref)
-  , fPlugins(ref.fPlugins)
-  , fCuts(ref.fCuts)  
-  , fHFEpid(ref.fHFEpid)
-  , fPIDdetectors(ref.fPIDdetectors)
-  , fPIDstrategy(ref.fPIDstrategy)
-  , fCFM(ref.fCFM)
-  , fDCA(ref.fDCA)
-  , fNclustersITS(ref.fNclustersITS)
-  , fMinNprimVtxContrbutor(ref.fMinNprimVtxContrbutor)
-  , fNEvents(ref.fNEvents)
-  , fResidualList(ref.fResidualList)
-  , fPullList(ref.fPullList)
-  , fDcaList(ref.fDcaList)
-  , fKfDcaList(ref.fKfDcaList)
-  , fMcVertexList(ref.fMcVertexList)
-  , fDataDcaList(ref.fDataDcaList)
-  , fDataVertexList(ref.fDataVertexList)
-  , fDataPullList(ref.fDataPullList)
-  , fMcPidList(ref.fMcPidList)
-  , fDataPidList(ref.fDataPidList)
-  , fHfeDcaList(ref.fHfeDcaList)
-  , fHfeDataDcaList(ref.fHfeDataDcaList)
-  , fOutput(ref.fOutput)
-{
-  //
-  // Copy Constructor
-  //
-  AliInfo("Copy Constructor");
-  ref.Copy(*this);
-}
-
-//____________________________________________________________
-AliAnalysisTaskDCA &AliAnalysisTaskDCA::operator=(const AliAnalysisTaskDCA &ref){
-  //
-  // Assignment operator
-  //
-  if(this == &ref) return *this;
-  AliAnalysisTaskSE::operator=(ref);
-  fPlugins = ref.fPlugins;
-  fCuts = ref.fCuts;
-  fHFEpid = ref.fHFEpid;
-  fPIDdetectors = ref.fPIDdetectors;
-  fPIDstrategy = ref.fPIDstrategy;
-  fCFM = ref.fCFM;
-  fDCA = ref.fDCA;
-  fNclustersITS = ref.fNclustersITS;
-  fMinNprimVtxContrbutor = ref.fMinNprimVtxContrbutor;
-  fNEvents = ref.fNEvents;
-  fResidualList = ref.fResidualList;
-  fPullList = ref.fPullList;
-  fDcaList = ref.fDcaList;
-  fKfDcaList = ref.fKfDcaList;
-  fMcVertexList = ref.fMcVertexList;
-  fDataDcaList = ref.fDataDcaList;
-  fDataVertexList = ref.fDataVertexList;
-  fDataPullList = ref.fDataPullList;
-  fMcPidList = ref.fMcPidList;
-  fDataPidList = ref.fDataPidList;
-  fHfeDcaList = ref.fHfeDcaList;    
-  fHfeDataDcaList = ref.fHfeDataDcaList;
-  fOutput = ref.fOutput;
-
-  return *this;
-}
-
-//____________________________________________________________
-AliAnalysisTaskDCA::~AliAnalysisTaskDCA(){
-  //
-  // Destructor
-  //
-
-  if(fHFEpid) delete fHFEpid;
-  if(fCFM) delete fCFM;
-  if(fDCA) delete fDCA;  
-  if(fNEvents) delete fNEvents;
-  if(fResidualList){ 
-    fResidualList->Clear();
-    delete fResidualList;
-  }
-
-  if(fPullList){ 
-    fPullList->Clear();
-    delete fPullList;
-  }
-  
-  if(fDcaList){ 
-    fDcaList->Clear();
-    delete fDcaList;
-  }
-  if(fKfDcaList){ 
-    fKfDcaList->Clear();
-    delete fKfDcaList;
-  }
-
-  if(fMcVertexList){
-    fMcVertexList->Clear();
-    delete   fMcVertexList;
-  }
-
-  if(fDataDcaList){ 
-    fDataDcaList->Clear();
-    delete fDataDcaList;
-  }
-
-  if(fDataVertexList){
-    fDataVertexList->Clear();
-    delete   fDataVertexList;
-  }
-  if(fDataPullList){ 
-    fDataPullList->Clear();
-    delete fDataPullList;
-  }
-
-  if(fMcPidList){
-    fMcPidList -> Clear();
-    delete fMcPidList;
-  }
-  if(fDataPidList){
-    fDataPidList -> Clear();
-    delete fDataPidList;
-  }
-
-  if(fHfeDcaList) {
-    fHfeDcaList->Clear();
-    delete fHfeDcaList;
-  } 
-  
-  if(fHfeDataDcaList) {
-    fHfeDataDcaList->Clear();
-    delete fHfeDataDcaList;
-  } 
-  
-  if(fOutput){ 
-    fOutput->Clear();
-    delete fOutput;
-  }
-  
-}
-
-//____________________________________________________________
-void AliAnalysisTaskDCA::UserCreateOutputObjects(){
-  // create output objects
-  // fNEvents
-  // residual and pull
-  //printf("\n=====UserCreateOutputObjects=====\n");
-  
-  // Automatic determination of the analysis mode
-  AliVEventHandler *inputHandler = dynamic_cast<AliVEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
-  if(!inputHandler){
-    AliError("NoEvent Handler available");
-    return;
-  }
-
-  if(!TString(inputHandler->IsA()->GetName()).CompareTo("AliAODInputHandler")){
-    SetAODAnalysis();
-  } else {
-    SetESDAnalysis();
-    if(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler())
-      SetHasMCData();
-  }
-  
-
-  fNEvents = new TH1I("nEvents", "Number of Events in the Analysis", 5, -0.5, 4.5); // Number of Events neccessary for the analysis and not a QA histogram
-  if(!fOutput) fOutput = new TList;
-  // Initialize correction Framework and Cuts
-  fCFM = new AliCFManager;
-  MakeParticleContainer();
-  // Temporary fix: Initialize particle cuts with 0x0
-  for(Int_t istep = 0; istep < fCFM->GetParticleContainer()->GetNStep(); istep++)
-    fCFM->SetParticleCutsList(istep, 0x0);
-  if(!fCuts){
-    AliWarning("Cuts not available. Default cuts will be used");
-    fCuts = new AliHFEcuts;
-    fCuts->CreateStandardCuts();
-  }
-  
-  fCuts->Initialize(fCFM);
-  
-  if(!fHFEpid) AliWarning("Hello, fHFEpid is not available");
-  cout<<"  Hello this is a cout "<<endl<<endl;
-
-  if(GetPlugin(kHFEpid)) {   
-    fHFEpid->SetHasMCData(HasMCData());
-    fHFEpid->AddDetector("TOF", 0);
-    fHFEpid->AddDetector("TPC", 1);
-    cout<<endl<<" ---> TPC and TOF added to the PID"<<endl;
-               fHFEpid->ConfigureTOF();
-    fHFEpid->ConfigureTPCdefaultCut();
-    fHFEpid->InitializePID();
-  }
-
-  // dca study----------------------------------
-
-  
-  if(!fDCA) fDCA = new AliHFEdca;
-  if(!fResidualList) fResidualList = new TList();
-  if(!fPullList) fPullList = new TList();
-  if(!fDcaList) fDcaList = new TList();
-  if(!fKfDcaList) fKfDcaList = new TList();
-  if(!fMcVertexList) fMcVertexList = new TList();
-  if(!fDataDcaList) fDataDcaList = new TList();
-  if(!fDataVertexList) fDataVertexList = new TList();
-  if(!fDataPullList) fDataPullList = new TList();
-  if(!fMcPidList) fMcPidList = new TList();
-  if(!fDataPidList) fDataPidList = new TList();  
-  
-  if(!fHfeDcaList) fHfeDcaList = new TList();
-  if(!fHfeDataDcaList) fHfeDataDcaList = new TList();
-
-  if(HasMCData()) {    
-    if(GetPlugin(kImpactPar) ) {
-      fDCA->CreateHistogramsResidual(fResidualList);
-      fDCA->CreateHistogramsPull(fPullList);
-      fDCA->CreateHistogramsDca(fDcaList);
-      fOutput->AddAt(fResidualList,0);
-      fOutput->AddAt(fPullList,1);
-      fOutput->AddAt(fDcaList,2);
-    } 
-    if(GetPlugin(kKFdca)){
-      fDCA->CreateHistogramsKfDca(fKfDcaList);
-      fOutput->AddAt(fDcaList,3);
-    }
-    if(GetPlugin(kPrimVtx)){//<---
-      fDCA->CreateHistogramsVertex(fMcVertexList);
-      fOutput->AddAt(fMcVertexList,4);
-    }
-    if(GetPlugin(kCombinedPid)){//<---
-      fDCA->CreateHistogramsPid(fMcPidList);
-      fOutput->AddAt(fMcPidList, 5);
-    }
-    if(GetPlugin(kHFEpid)){//<---
-      fDCA->CreateHistogramsHfeDca(fHfeDcaList);
-      fOutput->AddAt(fHfeDcaList, 6);
-    }
-  } // mc case
-
-  if(!HasMCData())  { 
-    
-    if(GetPlugin(kPrimVtx)){
-      fDCA->CreateHistogramsDataVertex(fDataVertexList);  
-      fOutput->AddAt(fDataVertexList,0);
-    }    
-
-    if(GetPlugin(kCombinedPid)){
-      fDCA->CreateHistogramsDataDca(fDataDcaList);  
-      fDCA->CreateHistogramsDataPull(fDataPullList);  
-      fDCA->CreateHistogramsDataPid(fDataPidList);
-      fOutput->AddAt(fDataDcaList,1);
-      fOutput->AddAt(fDataPullList,2);
-      fOutput->AddAt(fDataPidList, 3);
-    }
-    if(GetPlugin(kHFEpid)){
-      fDCA->CreateHistogramsHfeDataDca(fHfeDataDcaList);
-      fOutput->AddAt(fHfeDataDcaList, 4);
-    }
-    
-
-
-  }  // data case
-  
-}
-
-//____________________________________________________________
-void AliAnalysisTaskDCA::UserExec(Option_t *){
-  //
-  // Run the analysis
-  // 
-  //printf("\n=====UserExec=====\n");
-  if(HasMCData()) printf("WITH MC!\n");
-
-  AliDebug(3, "Processing ESD events");
-
-  if(!fInputEvent){
-    AliError("Reconstructed Event not available");
-    return;
-  }
-  if(HasMCData()){
-    AliDebug(4, Form("MC Event: %p", fMCEvent));
-    if(!fMCEvent){
-      AliError("No MC Event, but MC Data required");
-      return;
-    }
-  }
-
-  if(!fCuts){
-    AliError("HFE cuts not available");
-    return;
-  }
-
-  // protection
-  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;
-  }
-
-  
-  AliPIDResponse *pidResponse = fInputHandler->GetPIDResponse();
-  if(!pidResponse){
-    AliDebug(1, "Using default PID Response");
-    pidResponse = AliHFEtools::GetDefaultPID(HasMCData(), fInputEvent->IsA() == AliAODEvent::Class());
-  }
-  fHFEpid->SetPIDResponse(pidResponse);
-  ProcessDcaAnalysis();
-
-  PostData(1, fNEvents);
-  PostData(2, fOutput);
-}
-//____________________________________________________________
-void AliAnalysisTaskDCA::ProcessDcaAnalysis(){
-
-  //printf("\n=====ProcessDcaAnalysis=====\n");
-
-  //
-  // Loop ESD
-  //
-  AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);
-  if(!fESD){
-    AliError("ESD Event required for ESD Analysis");
-      return;
-  }
-
-  AliMCEvent *fMC = 0x0;
-  if(HasMCData()){
-    fMC = dynamic_cast<AliMCEvent*>(fMCEvent);
-    if(!fMC){
-      AliError("MC Event required for Analysis");
-      return;
-    }
-  }
-
-  fNEvents->Fill(1);  // original event number before cut
-  fDCA->ApplyExtraCuts(fESD,fMinNprimVtxContrbutor);  // cut on primVtx contributors
-  fNEvents->Fill(3);  // events number after cut
-  fCFM->SetRecEventInfo(fESD);
-  // event cut level
-  if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fESD)) return;
-
-  AliESDtrack *track = 0x0;  
-  AliMCParticle *mctrack = 0x0;
-  AliESDVertex *vtxESDSkip = 0x0;
-  AliHFEpidObject hfetrack;
-
-  for(Int_t itrack = 0; itrack < fESD->GetNumberOfTracks(); itrack++){
-    
-    track = fESD->GetTrack(itrack);
-    if(HasMCData()) mctrack = dynamic_cast<AliMCParticle *>(fMC->GetTrack(TMath::Abs(track->GetLabel())));
-
-    // RecPrim: primary cuts
-    if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepRecPrim + AliHFEcuts::kNcutStepsMCTrack, track)) continue;
-    // RecKine: ITSTPC cuts  
-    if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepRecKineITSTPC + AliHFEcuts::kNcutStepsMCTrack, track)) continue;
-    // HFEcuts: ITS layers cuts
-    if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsITS + AliHFEcuts::kNcutStepsMCTrack, track)) continue;
-    
-    if(track->GetITSclusters(0)<=fNclustersITS) continue;  // require number of ITS clusters
-    
-    // track accepted, do PID
-    hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);
-    hfetrack.SetRecTrack(track);
-    if(HasMCData()) hfetrack.SetMCTrack(mctrack);
-
-    //printf("Track %d passed all the cuts!\n",itrack);
-
-    if(HasMCData()){
-      if(GetPlugin(kPrimVtx))
-       fDCA->FillHistogramsVtx(fESD, fMC);
-      if(GetPlugin(kImpactPar)) 
-       fDCA->FillHistogramsDca(fESD, track, fMC);
-      if(GetPlugin(kKFdca)) 
-       fDCA->FillHistogramsKfDca(fESD, track, fMC);
-      if(GetPlugin(kCombinedPid)) 
-       fDCA->FillHistogramsPid(track, fMC);
-      if(GetPlugin(kHFEpid)) { // data-like
-       if(fHFEpid->IsSelected(&hfetrack)){ 
-         
-         //      printf("Found an electron in p+p collision! from HFE pid \n");
-         if(!vtxESDSkip){
-           // method from Andrea D 28.05.2010
-           AliVertexerTracks *vertexer = new AliVertexerTracks(fESD->GetMagneticField());
-           vertexer->SetITSMode();
-           vertexer->SetMinClusters(fNclustersITS);
-           Int_t skipped[2];
-           skipped[0] = (Int_t)track->GetID();
-           vertexer->SetSkipTracks(1,skipped);
-           vtxESDSkip = (AliESDVertex*)vertexer->FindPrimaryVertex(fESD);
-           delete vertexer; vertexer = NULL;
-           if(vtxESDSkip->GetNContributors()<fMinNprimVtxContrbutor) continue;
-         }
-         //printf("\n[ABOUT TO FILL HFE DCA: MC!]\n");
-         fDCA->FillHistogramsHfeDataDca(fESD, track, vtxESDSkip); 
-       }
-      } // plugin for hfepid 
-    }  // MC
-
-    if(!HasMCData()){
-      if(GetPlugin(kPrimVtx))
-       fDCA->FillHistogramsDataVtx(fESD);
-      if(GetPlugin(kCombinedPid)) {
-
-       // method from Andrea D 28.05.2010
-       AliVertexerTracks *vertexer = new AliVertexerTracks(fESD->GetMagneticField());
-       vertexer->SetITSMode();
-       vertexer->SetMinClusters(fNclustersITS);
-       Int_t skipped[2];
-       skipped[0] = (Int_t)track->GetID();
-       vertexer->SetSkipTracks(1,skipped);
-       vtxESDSkip = (AliESDVertex*)vertexer->FindPrimaryVertex(fESD);
-       delete vertexer; vertexer = NULL;
-       if(vtxESDSkip->GetNContributors()<fMinNprimVtxContrbutor) continue;
-
-       fDCA->FillHistogramsDataDca(fESD, track, vtxESDSkip);
-       fDCA->FillHistogramsDataPid(track);
-      }
-      if(GetPlugin(kHFEpid)) {
-       if(fHFEpid->IsSelected(&hfetrack)) {
-         //      printf("Found an electron in p+p collision! from HFE pid \n");
-         if(!vtxESDSkip){
-           // method from Andrea D 28.05.2010
-           AliVertexerTracks *vertexer = new AliVertexerTracks(fESD->GetMagneticField());
-           vertexer->SetITSMode();
-           vertexer->SetMinClusters(fNclustersITS);
-           Int_t skipped[2];
-           skipped[0] = (Int_t)track->GetID();
-           vertexer->SetSkipTracks(1,skipped);
-           vtxESDSkip = (AliESDVertex*)vertexer->FindPrimaryVertex(fESD);
-           delete vertexer; vertexer = NULL;
-           if(vtxESDSkip->GetNContributors()<fMinNprimVtxContrbutor) continue;
-         }
-       printf("\n[ABOUT TO FILL HFE DCA: DATA!]\n");
-         fDCA->FillHistogramsHfeDataDca(fESD, track,vtxESDSkip);    
-       } 
-      } // plugin for hfepid
-    }  // data case
-
-  } // track loop
-
-}
-
-
-//____________________________________________________________
-void AliAnalysisTaskDCA::Terminate(Option_t *){
-  //
-  // Terminate not implemented at the moment
-  //  
-  //printf("\n=====Terminate=====\n");
-  
-  if(GetPlugin(kPostProcess)){
-    fOutput = dynamic_cast<TList *>(GetOutputData(1));
-    if(!fOutput){
-      AliError("Results not available");
-      return;
-    }
-    PostProcess();
-  }
-  
-}
-
-
-//____________________________________________________________
-void AliAnalysisTaskDCA::Load(TString filename){
-
-  //printf("\n=====Load=====\n");
-
-  // no need for postprocessing for the moment
-  TFile *input = TFile::Open(filename.Data());
-  if(!input || input->IsZombie()){
-    AliError("Cannot read file");
-    return;
-  }
-
-  input->Close();
-  delete input;
-  
-  
-}
-
-//____________________________________________________________
-void AliAnalysisTaskDCA::PostProcess(){
-  // do post processing
-  // should do fitting here for dca resolution
-  // moved to an external macro to do the job
-  
-  //printf("\n=====PostProcess=====\n");
-  Load("HFEdca.root");
-  TCanvas *c1 = new TCanvas("c1", "number of analyzed events", 300, 400);
-  fNEvents->Draw();
-  c1->SaveAs("temp.png");
-}
-
-
-
-
-//____________________________________________________________
-void AliAnalysisTaskDCA::PrintStatus() const {
-  
-  //
-  // Print Analysis status
-  //
-  printf("\n\tAnalysis Settings\n\t========================================\n");
-  printf("\t Running on %s\n", !HasMCData()?"p+p collision data":"MC sample");
-  printf("\t Cuts: %s\n", (fCuts != NULL) ? "YES" : "NO");
-  printf("\t Impact parameter analysis is %s\n", GetPlugin(kImpactPar)?"ON":"OFF");
-  printf("\t Using AliKFParticle for analysis? %s\n", GetPlugin(kKFdca)?"ON":"OFF");
-  printf("\t Primary vertex analysis is %s\n", GetPlugin(kPrimVtx)?"ON":"OFF");
-  printf("\t Combined pid analysis is %s\n", GetPlugin(kCombinedPid)?"ON":"OFF");
-  printf("\t HFE pid analysis is %s\n", GetPlugin(kHFEpid)?"ON":"OFF");
-  printf("\t Post process analysis is %s\n", GetPlugin(kPostProcess)?"ON":"OFF");
-  printf("\t ");
-  printf("\n");
-}
-
-//__________________________________________                                                  
-void AliAnalysisTaskDCA::SwitchOnPlugin(Int_t plug){
-  //                                            
-  // Switch on Plugin          
-  // Available:                                  
-  //  - analyze impact parameter
-  //  - Post Processing  
-
-  AliDebug(2,Form("SwitchOnPlugin %d",plug));  
-
-  switch(plug){
-  case kPostProcess: 
-    SETBIT(fPlugins, plug); 
-    break;
-  case kImpactPar: 
-    SETBIT(fPlugins, plug); 
-    break;
-  case kPrimVtx: 
-    SETBIT(fPlugins, plug); 
-    break;
-  case kCombinedPid:
-    SETBIT(fPlugins, plug); 
-    break;
-  case kHFEpid:
-    SETBIT(fPlugins, plug); 
-    break;
-  case kKFdca:
-    SETBIT(fPlugins, plug); 
-    break;
-  default: 
-    AliError("Unknown Plugin");
-  };
-}
-
-
-//____________________________________________________________
-void AliAnalysisTaskDCA::MakeParticleContainer(){
-
-  //printf("\n=====MakeParticleContainer=====\n");
-  //
-  // Create the particle container (borrowed from AliAnalysisTaskHFE)
-  //
-  const Int_t kNvar   = 3 ; //number of variables on the grid:pt,eta, phi
-  const Double_t kPtmin = 0.1, kPtmax = 10.;
-  const Double_t kEtamin = -0.9, kEtamax = 0.9;
-  const Double_t kPhimin = 0., kPhimax = 2. * TMath::Pi();
-
-  //arrays for the number of bins in each dimension
-  Int_t iBin[kNvar];
-  iBin[0] = 40; //bins in pt
-  iBin[1] =  8; //bins in eta 
-  iBin[2] = 18; // bins in phi
-
-  //arrays for lower bounds :
-  Double_t* binEdges[kNvar];
-  for(Int_t ivar = 0; ivar < kNvar; ivar++)
-    binEdges[ivar] = new Double_t[iBin[ivar] + 1];
-
-  //values for bin lower bounds
-  for(Int_t i=0; i<=iBin[0]; i++) binEdges[0][i]=(Double_t)TMath::Power(10,TMath::Log10(kPtmin) + (TMath::Log10(kPtmax)-TMath::Log10(kPtmin))/iBin[0]*(Double_t)i);  
-  for(Int_t i=0; i<=iBin[1]; i++) binEdges[1][i]=(Double_t)kEtamin  + (kEtamax-kEtamin)/iBin[1]*(Double_t)i;
-  for(Int_t i=0; i<=iBin[2]; i++) binEdges[2][i]=(Double_t)kPhimin  + (kPhimax-kPhimin)/iBin[2]*(Double_t)i;
-
-  //one "container" for MC
-  const Int_t kNcutStepsESDtrack = AliHFEcuts::kNcutStepsRecTrack + 1;
-  const Int_t kNcutStepsTrack = AliHFEcuts::kNcutStepsMCTrack + kNcutStepsESDtrack;
-  AliCFContainer* container = new AliCFContainer("container","container for tracks", (kNcutStepsTrack + 1 + 2*(kNcutStepsESDtrack + 1)), kNvar, iBin);
-
-  //setting the bin limits
-  for(Int_t ivar = 0; ivar < kNvar; ivar++)
-    container -> SetBinLimits(ivar, binEdges[ivar]);
-  fCFM->SetParticleContainer(container);
-
-  //create correlation matrix for unfolding
-  Int_t thnDim[2*kNvar];
-  for (int k=0; k<kNvar; k++) {
-    //first half  : reconstructed 
-    //second half : MC
-    thnDim[k]      = iBin[k];
-    thnDim[k+kNvar] = iBin[k];
-  }
-
-
-}
-
-//____________________________________________________________
-void AliAnalysisTaskDCA::AddPIDdetector(TString detector){
-  
-  //
-  // Adding PID detector to the task
-  //
-  //printf("\n=====AddPIDdetector=====\n");
-  
-  if(!fPIDdetectors.Length()) 
-    fPIDdetectors = detector;
-  else
-    fPIDdetectors += ":" + detector;
-}
-
diff --git a/PWGHF/hfe/AliAnalysisTaskDCA.h b/PWGHF/hfe/AliAnalysisTaskDCA.h
deleted file mode 100644 (file)
index aea45c4..0000000
+++ /dev/null
@@ -1,133 +0,0 @@
-/**************************************************************************
-* 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.                  *
-**************************************************************************/
-//
-// Task for impact parameter (DCA) analysis
-// study DCA in rphi (xy) and z: resolution and pull 
-// For further information see implementation file
-
-
-#ifndef ALIANALYSISTASKDCA_H
-#define ALIANALYSISTASKDCA_H
-#ifndef ALIANALYSISTASKSE_H
-#include "AliAnalysisTaskSE.h"
-#endif
-
-class TH1I; 
-class TH1F; 
-class TList;
-class AliLog;
-class AliCFManager;
-class AliESDEvent;
-class AliESDtrackCuts;
-class AliMCEvent;
-class AliVParticle;
-
-class AliVEvent;
-class AliVertexerTracks;
-class AliHFEpid;
-class AliHFEcuts;
-class AliHFEextraCuts;
-
-class AliAnalysisTaskDCA : public AliAnalysisTaskSE{
- public:
-
-  typedef enum{
-    kPostProcess = 0,
-    kImpactPar = 1,
-    kPrimVtx = 2,
-    kCombinedPid = 3,
-    kHFEpid = 4, 
-    kKFdca = 5
-  }Switches_t;
-
-  enum{
-    kHasMCdata = BIT(19),
-    kAODanalysis = BIT(20)
-  };
-  
-  AliAnalysisTaskDCA();
-  AliAnalysisTaskDCA(const char * name);
-  AliAnalysisTaskDCA(const AliAnalysisTaskDCA &ref);
-  AliAnalysisTaskDCA& operator=(const AliAnalysisTaskDCA &ref);
-  virtual ~AliAnalysisTaskDCA();
-  
-  virtual void UserCreateOutputObjects();
-  virtual void UserExec(Option_t *);
-  virtual void Terminate(Option_t *);
-
-
-  void PrintStatus() const;
-  void Load(TString filename = "impactPar.root");
-  void PostProcess();
-  void SetHFECuts(AliHFEcuts * const cuts) { fCuts = cuts; };
-
-  void SetNclustersITS(Int_t nITSclusters){ fNclustersITS = nITSclusters;};
-  void SetMinPrimVtxContrib( Int_t nPrimVtxContrib){ fMinNprimVtxContrbutor = nPrimVtxContrib; };  
-
-  Bool_t GetPlugin(Int_t plug) const { return TESTBIT(fPlugins, plug); };
-  void SwitchOnPlugin(Int_t plug);
-
-  Bool_t IsAODanalysis() const { return TestBit(kAODanalysis); };
-  Bool_t IsESDanalysis() const { return !TestBit(kAODanalysis); };
-  Bool_t HasMCData() const { return TestBit(kHasMCdata); }
-  void SetHasMCData(Bool_t hasMC = kTRUE) { SetBit(kHasMCdata, hasMC); };
-
-  void SetPIDdetectors(Char_t * const detectors){ fPIDdetectors = detectors; }
-  void SetPIDStrategy(UInt_t strategy) { fPIDstrategy = strategy; }
-  void AddPIDdetector(TString detector);
-
-  void SetAODAnalysis() { SetBit(kAODanalysis, kTRUE); };
-  void SetESDAnalysis() { SetBit(kAODanalysis, kFALSE); };
-
-
- private:
-
-  void MakeParticleContainer();
-  void ProcessDcaAnalysis();
-    
-  UShort_t fPlugins;                   // Enabled Plugins 
-  AliHFEcuts *fCuts;                   // Cut Collection
-
-  AliHFEpid *fHFEpid;                  //! PID
-  TString fPIDdetectors;               // Detectors for Particle Identification
-  UInt_t fPIDstrategy;                 // PID Strategy
-
-  AliCFManager *fCFM;                  //! Correction Framework Manager
-  AliHFEdca *fDCA;                     // fDCA 
-
-  Int_t fNclustersITS;                 // ITS clusters
-  Int_t fMinNprimVtxContrbutor;        // minimum number of primary contributors
-                                               
-  TH1I *fNEvents;                      //! counter for the number of Events
-  TList *fResidualList;                //! histograms for the residuals 
-  TList *fPullList;                    //! histograms for the pull
-  TList *fDcaList;                     //! histograms for the dca
-  TList *fKfDcaList;                     //! histograms for the kf dca
-  TList *fMcVertexList;                //! histograms for the MC vertex  
-  TList *fDataDcaList;                 //! histograms for the data dca
-  TList *fDataVertexList;              //! histograms for the data vertex
-  TList *fDataPullList;                //! histograms for the data pull
-  TList *fMcPidList;                   //! pid - MC: ESD combined pid
-  TList *fDataPidList;                 //! pid -Data: ESD combined pid
-
-  TList *fHfeDcaList;                  //! hfe pid: mc dca 
-  TList *fHfeDataDcaList;              //! hfe pid: data dca 
-
-  TList *fOutput;                      //! Container for Task Output
-
-  ClassDef(AliAnalysisTaskDCA, 1);     // The DCA Analysis Task
-};
-#endif
-
diff --git a/PWGHF/hfe/AliAnalysisTaskDisplacedElectrons.cxx b/PWGHF/hfe/AliAnalysisTaskDisplacedElectrons.cxx
deleted file mode 100644 (file)
index 917f8d5..0000000
+++ /dev/null
@@ -1,840 +0,0 @@
-/**************************************************************************
-* 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:
-// study displaced electrons from beauty and charm 
-// with cut on impact parameters in various pT bins
-// 
-// 
-// Authors:
-//  Hongyan Yang <hongyan@physi.uni-heidelberg.de>
-//  Carlo Bombonati <Carlo.Bombonati@cern.ch>
-//
-
-#include <TChain.h>
-#include <TFile.h>
-#include <TH1F.h>
-#include <TH1I.h>
-#include "AliLog.h"
-
-#include <TList.h>
-#include <TMath.h>
-#include <TObjArray.h>
-#include <TParticle.h>
-#include <TString.h>
-#include <TCanvas.h>
-
-#include "AliAODEvent.h"
-#include "AliCFManager.h"
-#include "AliMCEvent.h"
-#include "AliMCEventHandler.h"
-#include "AliMCParticle.h"
-#include "AliPIDResponse.h"
-#include "AliStack.h"
-
-#include "AliESDEvent.h"
-#include "AliESDInputHandler.h"
-#include "AliESDtrack.h"
-
-#include "AliAnalysisManager.h"
-
-#include "AliHFEpid.h"
-#include "AliHFEcuts.h"
-#include "AliHFEtools.h"
-#include "AliHFEdisplacedElectrons.h"
-#include "AliAnalysisTaskDisplacedElectrons.h"
-
-
-//____________________________________________________________
-AliAnalysisTaskDisplacedElectrons::AliAnalysisTaskDisplacedElectrons():
-  AliAnalysisTaskSE("Task for displaced electron study")
-  , fDeDebugLevel(0)
-  , fNminITSCluster(0)
-  , fNminPrimVtxContrib(0)
-  , fDePIDdetectors("")
-  , fDePIDstrategy(0)
-  , fDePlugins(0)
-  , fDeCuts(0x0)
-  , fDePID(0x0)
-  , fDeCFM(0x0)
-  , fDisplacedElectrons(0x0)
-  , fDeNEvents(0x0)
-  , fElectronsMcPt(0x0)
-  , fElectronsEsdPt(0x0)
-  , fElectronsDataPt(0x0)
-  , fDeCorrection(0x0)
-  , fDeQA(0x0)
-  , fHistDisplacedElectrons(0x0)
-{
-  //
-  // Dummy constructor
-  //
-}
-
-//____________________________________________________________
-AliAnalysisTaskDisplacedElectrons::AliAnalysisTaskDisplacedElectrons(const char * name):
-  AliAnalysisTaskSE(name)
-  , fDeDebugLevel(0)
-  , fNminITSCluster(0)
-  , fNminPrimVtxContrib(0)
-  , fDePIDdetectors("")
-  , fDePIDstrategy(0)
-  , fDePlugins(0)
-  , fDeCuts(0x0)
-  , fDePID(0x0)
-  , fDeCFM(0x0)
-  , fDisplacedElectrons(0x0)
-  , fDeNEvents(0x0)
-  , fElectronsMcPt(0x0)
-  , fElectronsEsdPt(0x0)
-  , fElectronsDataPt(0x0)
-  , fDeCorrection(0x0)
-  , fDeQA(0x0)
-  , fHistDisplacedElectrons(0x0)
-{
-  //
-  // Default constructor
-  //
-  DefineInput(0, TChain::Class());
-  DefineOutput(1, TList::Class());
-  DefineOutput(2, TList::Class());
-  DefineOutput(3, TList::Class());
-
-  // Initialize pid
-  fDePID = new AliHFEpid("DEPID");
-
-}
-
-//____________________________________________________________
-AliAnalysisTaskDisplacedElectrons::AliAnalysisTaskDisplacedElectrons(const AliAnalysisTaskDisplacedElectrons &ref):
-  AliAnalysisTaskSE(ref)
-  , fDeDebugLevel(ref.fDeDebugLevel)
-  , fNminITSCluster(ref.fNminITSCluster)
-  , fNminPrimVtxContrib(ref.fNminPrimVtxContrib)
-  , fDePIDdetectors(ref.fDePIDdetectors)
-  , fDePIDstrategy(ref.fDePIDstrategy)
-  , fDePlugins(ref.fDePlugins)
-  , fDeCuts(ref.fDeCuts)
-  , fDePID(ref.fDePID)
-  , fDeCFM(ref.fDeCFM)
-  , fDisplacedElectrons(ref.fDisplacedElectrons)
-  , fDeNEvents(ref.fDeNEvents)
-  , fElectronsMcPt(ref.fElectronsMcPt)
-  , fElectronsEsdPt(ref.fElectronsEsdPt)
-  , fElectronsDataPt(ref.fElectronsDataPt)
-  , fDeCorrection(ref.fDeCorrection)
-  , fDeQA(ref.fDeQA)
-  , fHistDisplacedElectrons(ref.fHistDisplacedElectrons)
-{
-  //
-  // Copy Constructor
-  //
-}
-
-//____________________________________________________________
-AliAnalysisTaskDisplacedElectrons &AliAnalysisTaskDisplacedElectrons::operator=(const AliAnalysisTaskDisplacedElectrons &ref){
-  //
-  // Assignment operator
-  //
-  if(this == &ref) return *this;
-  AliAnalysisTask::operator=(ref);
-  fDeDebugLevel = ref.fDeDebugLevel;
-  fNminITSCluster = ref.fNminITSCluster;
-  fNminPrimVtxContrib = ref.fNminPrimVtxContrib;
-  fDePIDdetectors = ref.fDePIDdetectors;
-  fDePIDstrategy = ref.fDePIDstrategy;
-  fDePlugins = ref.fDePlugins;
-  fDePID = ref.fDePID;
-  fDeCuts = ref.fDeCuts;
-  fDeCFM = ref.fDeCFM;
-  fDisplacedElectrons = ref.fDisplacedElectrons;
-  fDeNEvents = ref.fDeNEvents;
-  fElectronsMcPt = ref.fElectronsMcPt;
-  fElectronsEsdPt = ref.fElectronsEsdPt;
-  fElectronsDataPt = ref.fElectronsDataPt;
-  fDeCorrection = ref.fDeCorrection;
-  fDeQA = ref.fDeQA;
-  fHistDisplacedElectrons = ref.fHistDisplacedElectrons;
-
-  return *this;
-}
-
-//____________________________________________________________
-AliAnalysisTaskDisplacedElectrons::~AliAnalysisTaskDisplacedElectrons(){
-  //
-  // Destructor
-  //
-
-  if(fDePID) delete fDePID;
-  if(fDeCFM) delete fDeCFM;
-  if(fDisplacedElectrons) delete fDisplacedElectrons;  
-  if(fDeNEvents) delete fDeNEvents;
-  if(fElectronsMcPt) delete fElectronsMcPt;
-  if(fElectronsEsdPt) delete fElectronsEsdPt;
-  if(fElectronsDataPt) delete fElectronsDataPt;
-  if(fDeCorrection){
-    fDeCorrection->Clear();
-    delete fDeCorrection;
-  }
-  if(fDeQA){
-    fDeQA->Clear();
-    delete fDeQA;
-  }
-  if(fHistDisplacedElectrons){ 
-    fHistDisplacedElectrons->Clear();  
-    delete fHistDisplacedElectrons;  
-  }
-}
-
-//____________________________________________________________
-void AliAnalysisTaskDisplacedElectrons::UserCreateOutputObjects(){
-  // create output objects
-  // fDeNEvents
-  // MC and Data containers
-
-
-  if(!fDeQA) fDeQA = new TList;
-  fDeQA->SetName("variousQAhistograms");
-  
-  fDeNEvents = new TH1I("nDeEvents", "Number of Events in the DE Analysis", 2, 0, 2); 
-  const Int_t nBins = 14;
-  const Float_t ptBins[nBins] = {0.0,0.5,1.0,1.5,2.0,2.5,3.0,4.0,5.0,7.0,9.0,12.0,16.0,20.0};
-  fElectronsMcPt = new TH1F("mcElectronPt", "MC: p_{T} distribution of identified electrons (mcpid);p_{T} (GeV/c);Counts;", nBins-1, ptBins); 
-  fElectronsEsdPt = new TH1F("esdElectronPt", "ESD: p_{T} distribution of identified electrons (hfepid);p_{T} (GeV/c);Counts;", nBins-1, ptBins); 
-  fElectronsDataPt = new TH1F("dataElectronPt", "DATA: p_{T} distribution of identified electrons (hfepid);p_{T} (GeV/c);Counts;", nBins-1, ptBins); 
-
-  fDeQA->AddAt(fDeNEvents,0);
-  if(HasMCData()){
-    fDeQA->AddAt(fElectronsMcPt, 1);
-    fDeQA->AddAt(fElectronsEsdPt, 2); 
-  }
-  else{
-    fDeQA->AddAt(fElectronsDataPt, 1);  
-  }
-  // Initialize correction Framework and Cuts
-  fDeCFM = new AliCFManager;
-  MakeEventContainer();
-  MakeParticleContainer();
-  if(!fDeCorrection) fDeCorrection = new TList();
-  fDeCorrection->SetName("deCorrections");
-  fDeCorrection->AddAt(fDeCFM->GetEventContainer(), 0);
-  fDeCorrection->AddAt(fDeCFM->GetParticleContainer(), 1);
-  fDeCorrection->Print();
-
-  for(Int_t istep = 0; istep < fDeCFM->GetEventContainer()->GetNStep(); istep++)
-    fDeCFM->SetEventCutsList(istep, 0x0);
-  for(Int_t istep = 0; istep < fDeCFM->GetParticleContainer()->GetNStep(); istep++)
-    fDeCFM->SetParticleCutsList(istep, 0x0);
-
-  if(!fDeCuts){
-    AliWarning("Cuts not available. Default cuts will be used");
-    fDeCuts = new AliHFEcuts;
-    fDeCuts->CreateStandardCuts();    
-  }
-  
-  fDeCuts->Initialize(fDeCFM);
-  
-  fDePID->SetHasMCData(HasMCData());
-  fDePID->AddDetector("TPC", 0);
-  fDePID->AddDetector("TOF", 1);
-       fDePID->ConfigureTOF();
-  fDePID->ConfigureTPCdefaultCut();
-  fDePID->InitializePID();     // Only restrictions to TPC allowed   
-
-
-  // displaced electron study----------------------------------
-  if(GetPlugin(kDisplacedElectrons)){
-    
-    fDisplacedElectrons = new AliHFEdisplacedElectrons;
-    fDisplacedElectrons->SetDebugLevel(fDeDebugLevel);
-    fDisplacedElectrons->SetHasMCData(HasMCData());
-    fDisplacedElectrons->SetMinPrimVtxContrib(fNminPrimVtxContrib);
-    fDisplacedElectrons->SetNitsCluster(fNminITSCluster);
-  
-    if(!fHistDisplacedElectrons) fHistDisplacedElectrons = new TList();
-    fDisplacedElectrons->CreateOutputs(fHistDisplacedElectrons);
-  }
-  
-}
-
-
-
-//____________________________________________________________
-void AliAnalysisTaskDisplacedElectrons::UserExec(Option_t *){
-  //
-  // Run the analysis
-  // 
-
-  if(fDeDebugLevel>=10) AliInfo("analyse single event");
-
-  if(!fInputEvent){
-    AliError("Reconstructed Event not available");
-    return;
-  }
-  //  
-  AliESDInputHandler *inH = dynamic_cast<AliESDInputHandler *>(fInputHandler);
-  
-  if(!inH){
-    AliError("AliESDInputHandler dynamic cast failed!");
-    return;
-  }
-  
-  // from now on, only ESD are analyzed
-  // using HFE pid, using HFE cuts
-  // using CORRFW
-  AliPIDResponse *pidResponse = fInputHandler->GetPIDResponse();
-  if(!pidResponse){
-    AliDebug(1, "Using default PID Response");
-    pidResponse = AliHFEtools::GetDefaultPID(HasMCData(), fInputEvent->IsA() == AliAODEvent::Class());
-  }
-  fDePID->SetPIDResponse(pidResponse);
-
-  if(!fDeCuts){
-    AliError("HFE cuts not available");
-    return;
-  }
-
-  // ---- CHOICE OF ANALYSIS ----
-  if(HasMCData()){
-    // Protect against missing MC trees
-    AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
-    if(!mcH){
-      AliError("MC handler cuts not available");
-      return;
-    }
-
-    if(!mcH->InitOk()) return;
-    if(!mcH->TreeK()) return;
-    if(!mcH->TreeTR()) return;            
-    
-    AliDebug(4, Form("MC Event: %p", fMCEvent));
-    if(!fMCEvent){
-      AliError("No MC Event, but MC Data required");
-      return;
-    }
-    
-    ProcessMC(); // PURE MC
-    
-    if(IsESDanalysis()) ProcessESD(); // ESD WITH MC
-    
-  }else if(IsESDanalysis()) ProcessData(); // PURE ESD
-  
-
-  fDeNEvents->Fill(1);  
-  PostData(1, fHistDisplacedElectrons);
-  PostData(2, fDeCorrection);
-  PostData(3, fDeQA);
-  
-}
-
-//____________________________________________________________
-void AliAnalysisTaskDisplacedElectrons::ProcessMC(){
-  //
-  // handle pure MC analysis
-  //
-
-  Int_t nMCelectrons = 0;
-  AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);
-  if(!fESD){
-    AliError("ESD event not available");
-    return;
-  }
-
-  Double_t mcContainer[4];   // container for the output in THnSparse
-  memset(mcContainer, 0, sizeof(Double_t) * 4);
-
-  fDeCFM->SetMCEventInfo(fMCEvent);
-
-  Double_t nContributor[1] = {0};
-  const AliVVertex *mcPrimVtx = fMCEvent->GetPrimaryVertex();
-  if(mcPrimVtx) nContributor[0] = mcPrimVtx->GetNContributors();
-  
-  // 
-  // cut at MC event level
-  //
-
-  if(!fDeCFM->CheckEventCuts(AliHFEcuts::kEventStepGenerated, fMCEvent)) return;
-  if(GetPlugin(kCorrection)) fDeCFM->GetEventContainer()->Fill(nContributor,AliHFEcuts::kEventStepGenerated);
-  
-  AliStack *stack = 0x0;
-  
-  if(!fMCEvent->Stack())return;
-  stack = fMCEvent->Stack();
-  Int_t nTracks = stack->GetNtrack();
-
-  AliMCParticle *mcTrack = 0x0;
-
-  for(Int_t itrack = 0; itrack<nTracks; itrack++){
-    if(!(stack->Particle(itrack))) continue;
-    if(mcTrack) mcTrack = 0x0;
-    mcTrack = dynamic_cast<AliMCParticle*>(fMCEvent->GetTrack(itrack));
-    if(!mcTrack) continue;
-    //TParticle *mcPart = stack->Particle(itrack);
-        
-    mcContainer[0] = mcTrack->Pt();
-    mcContainer[1] = mcTrack->Eta();
-    mcContainer[2] = mcTrack->Phi();
-    mcContainer[3] = mcTrack->Charge();
-    
-
-
-    if (!stack->IsPhysicalPrimary(mcTrack->GetLabel())) continue;
-    // no cut but require primary
-    if(GetPlugin(kCorrection))fDeCFM->GetParticleContainer()->Fill(mcContainer, 0);    
-        
-    // all pions for reference
-    if(TMath::Abs(mcTrack->Particle()->GetPdgCode())==AliHFEdisplacedElectrons::kPDGpion && GetPlugin(kCorrection))
-      fDeCFM->GetParticleContainer()->Fill(mcContainer, 1);
-    
-    // cut for signal: all MC electrons
-    if(TMath::Abs(mcTrack->Particle()->GetPdgCode())==AliHFEdisplacedElectrons::kPDGelectron && GetPlugin(kCorrection)) 
-      fDeCFM->GetParticleContainer()->Fill(mcContainer, 2);
-
-    // cut at track level kinematics: pt and eta
-    if(TMath::Abs(mcContainer[1])>=0.8 || mcContainer[0]>20 || mcContainer[0]<0.1) continue;
-
-    if(TMath::Abs(mcTrack->Particle()->GetPdgCode())==AliHFEdisplacedElectrons::kPDGelectron){
-      nMCelectrons++;
-      fElectronsMcPt->Fill(mcContainer[0]);
-    }  
-
-    if(GetPlugin(kCorrection))fDeCFM->GetParticleContainer()->Fill(mcContainer, 3);
-
-    
-    // fill MC THnSparse
-    fDisplacedElectrons->FillMcOutput(fESD, fMCEvent, mcTrack);
-    
-  }  // mc track loop 
-
-  if(fDeDebugLevel>=10) printf("there are %d electrons in this MC event", nMCelectrons);
-  
-}
-
-//____________________________________________________________
-void AliAnalysisTaskDisplacedElectrons::ProcessESD(){
-  
-  // this is to handle ESD tracks with MC information
-  // MC pid is only used when HFE pid is implemented, for comparison
-  // corrections are taken into account
-  
-  // process data: ESD tracks with MC information
-  
-  const Int_t kStepPID = AliHFEcuts::kStepHFEcutsTRD + 1;
-
-  Double_t esdContainer[4];   // container for the output in THnSparse
-  memset(esdContainer, 0, sizeof(Double_t) * 4);
-  AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);
-  if(!fESD){
-    AliError("No ESD event available");
-    return;
-  }
-
-  fDeCFM->SetRecEventInfo(fESD);
-  Double_t nContrib[1] = {fESD->GetPrimaryVertex()->GetNContributors()};
-
-  Bool_t alreadyseen = kFALSE;
-  AliLabelContainer cont(fESD->GetNumberOfTracks());
-  
-  Int_t nHFEelectrons = 0;  
-  AliESDtrack *track = 0x0;    
-  AliStack *stack = 0x0;
-
-  if(!(stack = fMCEvent->Stack())) return;
-  
-  //
-  // cut at ESD event level
-  //
-  if(!fDeCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fESD)) return;
-  if(GetPlugin(kCorrection)) fDeCFM->GetEventContainer()->Fill(nContrib, AliHFEcuts::kEventStepReconstructed);
-  
-  for(Int_t itrack = 0; itrack < fESD->GetNumberOfTracks(); itrack++){
-    track = fESD->GetTrack(itrack);
-    
-    if(GetPlugin(kDisplacedElectrons)) {
-      
-      esdContainer[0] = track->Pt();
-      esdContainer[1] = track->Eta();
-      esdContainer[2] = track->Phi();
-      esdContainer[3] = track->Charge();
-      
-      // before any cut
-      alreadyseen = cont.Find(TMath::Abs(track->GetLabel()));  
-      cont.Append(TMath::Abs(track->GetLabel()));  // check double counting
-      if(alreadyseen) continue;  // avoid double counting
-      if(GetPlugin(kCorrection)) fDeCFM->GetParticleContainer()->Fill(esdContainer, 1+AliHFEcuts::kStepRecNoCut + AliHFEcuts::kNcutStepsMCTrack);      
-      
-      // 1st track cut
-      // RecKine: ITSTPC cuts : ITS & TPC refit, covmatrix: (2, 2, 0.5, 0.5, 2); min_tpccls: 50, chi2_tpccls: 3.5
-      if(!fDeCFM->CheckParticleCuts(AliHFEcuts::kStepRecKineITSTPC + AliHFEcuts::kNcutStepsMCTrack, track)) continue;
-      if(GetPlugin(kCorrection)) fDeCFM->GetParticleContainer()->Fill(esdContainer, 1+AliHFEcuts::kStepRecKineITSTPC + AliHFEcuts::kNcutStepsMCTrack);
-      
-      // 2nd track cut
-      // RecPrim: cut on track quality : DCA to vertex max: 3cm and 10cm; reject kink daughters
-      if(!fDeCFM->CheckParticleCuts(AliHFEcuts::kStepRecPrim + AliHFEcuts::kNcutStepsMCTrack, track)) continue;
-      if(GetPlugin(kCorrection)) fDeCFM->GetParticleContainer()->Fill(esdContainer, 1+AliHFEcuts::kStepRecPrim + AliHFEcuts::kNcutStepsMCTrack);
-      
-      // 3rd track cut
-      // HFEcuts: ITS layers cuts: ITS pixel layer: kFirst, kSecond, kBoth, kNone or kAny
-      if(!fDeCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsITS + AliHFEcuts::kNcutStepsMCTrack, track)) continue;
-      if(GetPlugin(kCorrection))fDeCFM->GetParticleContainer()->Fill(esdContainer, 1+AliHFEcuts::kStepHFEcutsITS + AliHFEcuts::kNcutStepsMCTrack);
-
-      /*
-      //  4th track cut
-      // TRD: number of tracklets in TRD
-      if(!fDeCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsTRD + AliHFEcuts::kNcutStepsMCTrack, track)) continue;
-      if(GetPlugin(kCorrection)) fDeCFM->GetParticleContainer()->Fill(esdContainer, 1+AliHFEcuts::kStepHFEcutsTRD + AliHFEcuts::kNcutStepsMCTrack);
-      */
-      
-      // 5th track cut
-      // track accepted, do PID 
-      // --> only electron candidate will be processed
-      AliHFEpidObject hfetrack;
-      hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);
-      hfetrack.SetRecTrack(track);
-      //if(HasMCData())hfetrack.SetMCTrack(mctrack);
-      
-      if(!fDePID->IsSelected(&hfetrack)) continue;
-      else if(fDeDebugLevel>=10)
-       AliInfo("ESD info: this particle is identified as electron by HFEpid method \n");
-      if(GetPlugin(kCorrection)) fDeCFM->GetParticleContainer()->Fill(esdContainer, 1+kStepPID + AliHFEcuts::kNcutStepsMCTrack);
-    
-      // Fill Containers
-      nHFEelectrons++;
-      fElectronsEsdPt->Fill(esdContainer[0]);
-      fDisplacedElectrons->FillEsdOutput(fESD, track, stack);
-    
-    }  // displaced electron analysis on ESD with MC plugin
-  } // track loop  
-  
-  if(fDeDebugLevel>=10) printf("there are %d HFE electrons in this ESD event", nHFEelectrons);
-  
-}
-
-
-
-//____________________________________________________________
-void AliAnalysisTaskDisplacedElectrons::ProcessData(){
-
-  // this is a track loop over real data 
-  // no MC information at all 
-  // HFE pid is used
-  
-  const Int_t kNcutStepsESDtrack = AliHFEcuts::kNcutStepsRecTrack + 1;
-  //const Int_t kNcutStepsTrack = AliHFEcuts::kNcutStepsMCTrack + kNcutStepsESDtrack;
-  const Int_t kStepPID = AliHFEcuts::kStepHFEcutsTRD + 1;
-
-  AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);
-  if(!fESD){
-    AliError("No ESD event available");
-    return;
-  }
-
-  Double_t dataContainer[4];   // container for the output in THnSparse
-  memset(dataContainer, 0, sizeof(Double_t) * 4);
-  
-  Bool_t alreadyseen = kFALSE;
-  AliLabelContainer cont(fESD->GetNumberOfTracks());
-
-
-  AliESDtrack *track = 0x0;
-  Int_t nHFEelectrons= 0;
-  
-  fDeCFM->SetRecEventInfo(fESD);
-  Double_t nContrib[1] = {fESD->GetPrimaryVertex()->GetNContributors()};
-  if(!fDeCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fESD)) return;
-  if(GetPlugin(kCorrection)) fDeCFM->GetEventContainer()->Fill(nContrib, AliHFEcuts::kEventStepReconstructed);
-  
-  
-  for(Int_t itrack = 0; itrack < fESD->GetNumberOfTracks(); itrack++){
-    track = fESD->GetTrack(itrack);
-    
-    if(GetPlugin(kDisplacedElectrons)) {
-      
-      dataContainer[0] = track->Pt();
-      dataContainer[1] = track->Eta();
-      dataContainer[2] = track->Phi();
-      dataContainer[3] = track->Charge();
-      
-      alreadyseen = cont.Find(TMath::Abs(track->GetLabel()));  // double counted track
-      cont.Append(TMath::Abs(track->GetLabel()));
-      if(alreadyseen) continue;  // avoid double counting
-      if(GetPlugin(kCorrection))fDeCFM->GetParticleContainer()->Fill(&dataContainer[4], 
-                                                                    1+AliHFEcuts::kStepRecNoCut + AliHFEcuts::kNcutStepsMCTrack + kNcutStepsESDtrack);
-
-      // 1st track cut
-      // RecKine: ITSTPC cuts : ITS & TPC refit, covmatrix: (2, 2, 0.5, 0.5, 2); min_tpccls: 50, chi2_tpccls: 3.5
-      if(!fDeCFM->CheckParticleCuts(AliHFEcuts::kStepRecKineITSTPC + AliHFEcuts::kNcutStepsMCTrack, track)) continue;
-      if(GetPlugin(kCorrection)) fDeCFM->GetParticleContainer()->Fill(&dataContainer[4], 
-                                                                     1+AliHFEcuts::kStepRecKineITSTPC + AliHFEcuts::kNcutStepsMCTrack + kNcutStepsESDtrack);
-      
-      // 2nd track cut
-      // RecPrim: cut on track quality : DCA to vertex max: 3cm and 10cm; reject kink daughters
-      if(!fDeCFM->CheckParticleCuts(AliHFEcuts::kStepRecPrim + AliHFEcuts::kNcutStepsMCTrack, track))  continue;
-      if(GetPlugin(kCorrection)) fDeCFM->GetParticleContainer()->Fill(&dataContainer[4], 
-                                                                     1+AliHFEcuts::kStepRecPrim + AliHFEcuts::kNcutStepsMCTrack + kNcutStepsESDtrack);
-       
-      //  3rd track cut
-      // HFEcuts: ITS layers cuts: ITS pixel layer: kFirst, kSecond, kBoth, kNone or kAny
-      if(!fDeCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsITS, track)) continue;
-      if(GetPlugin(kCorrection)) fDeCFM->GetParticleContainer()->Fill(&dataContainer[4],
-                                                                     1+AliHFEcuts::kStepHFEcutsITS + AliHFEcuts::kNcutStepsMCTrack + kNcutStepsESDtrack);
-      
-      /*
-      //  4th track cut
-      // TRD: number of tracklets in TRD0
-      if(!fDeCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsTRD + AliHFEcuts::kNcutStepsMCTrack, track)) continue;
-      if(GetPlugin(kCorrection)) if(HasMCData())fDeCFM->GetParticleContainer()->Fill(&dataContainer[4], 
-                                                                                    1+AliHFEcuts::kStepHFEcutsTRD + AliHFEcuts::kNcutStepsMCTrack + kNcutStepsESDtrack);
-      */
-
-
-      // 5th track cut
-      // track accepted, do PID --> only electron candidate will be processed
-
-      AliHFEpidObject hfetrack;
-      hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);
-      hfetrack.SetRecTrack(track);
-      
-      if(!fDePID->IsSelected(&hfetrack)) continue;
-      else if(fDeDebugLevel>=10)
-       AliInfo("ESD info: this particle is identified as electron by HFEpid method \n");
-      if(GetPlugin(kCorrection)) fDeCFM->GetParticleContainer()->Fill(dataContainer,  1+kStepPID + AliHFEcuts::kNcutStepsMCTrack + kNcutStepsESDtrack);
-
-      nHFEelectrons++;
-      fElectronsDataPt->Fill(dataContainer[0]);
-      fDisplacedElectrons->FillDataOutput(fESD, track);
-    } // analyze displaced electrons plugin switched on
-  } // track loop  
-
-  if(fDeDebugLevel>=10) printf("there are %d HFE electrons in this DATA event", nHFEelectrons);
-}
-
-
-//____________________________________________________________
-void AliAnalysisTaskDisplacedElectrons::Terminate(Option_t *){
-  //
-  // Terminate not implemented at the moment
-  //  
-  
-  fHistDisplacedElectrons = dynamic_cast<TList *>(GetOutputData(1));
-  fDeCorrection = dynamic_cast<TList *>(GetOutputData(2));
-  fDeQA = dynamic_cast<TList *>(GetOutputData(3));
-  if(!fDeCorrection) AliError("correction list not available\n");
-  if(!fHistDisplacedElectrons) AliError("de list not available\n");
-  if(!fDeQA) AliError("qa list is not available\n");
-  
-  fHistDisplacedElectrons->Print();
-  fDeCorrection->Print();
-  fDeQA->Print();
-
-  AliInfo("analysis done!\n");
-  
-}
-
-//____________________________________________________________
-void AliAnalysisTaskDisplacedElectrons::PrintStatus() const {
-  
-  //
-  // Print Analysis status
-  //
-  printf("\n");
-  printf("\t Analysis Settings\n\t========================================\n");
-  printf("\t running over %s\n", HasMCData()?"MC data":"pp collision data");
-  printf("\t displaced electrons' analysis is %s\n", GetPlugin(kDisplacedElectrons)?"ON":"OFF");
-  printf("\t correction container is %s\n", GetPlugin(kCorrection)?"ON":"OFF");
-  printf("\t hfe pid qa is %s\n", GetPlugin(kDePidQA)?"ON":"OFF");
-  printf("\t post processing  is %s\n", GetPlugin(kPostProcess)?"ON":"OFF");
-  printf("\t cuts: %s\n", (fDeCuts != NULL) ? "YES" : "NO");
-  printf("\t ");
-  printf("\n");
-}
-
-//__________________________________________                                                  
-void AliAnalysisTaskDisplacedElectrons::SwitchOnPlugin(Int_t plug){
-  //                                            
-  // Switch on Plugin          
-  // Available:                                  
-  //  - analyze impact parameter
-  //  - Post Processing                                                                      
-  
-  switch(plug)
-    {
-    case kDisplacedElectrons: 
-      SETBIT(fDePlugins, plug); 
-      break;
-    case kCorrection:
-      SETBIT(fDePlugins, plug); 
-      break;
-    case kDePidQA:
-      SETBIT(fDePlugins, plug); 
-      break;
-    case kPostProcess: 
-      SETBIT(fDePlugins, plug); 
-      break;
-    default: 
-      AliError("Unknown Plugin");
-    };
-}
-
-//____________________________________________________________
-void AliAnalysisTaskDisplacedElectrons::MakeParticleContainer(){
-  //
-  // Create the particle container for the correction framework manager and 
-  // link it
-  //
-  const Int_t kNcutStepsESDtrack = AliHFEcuts::kNcutStepsRecTrack + 1;
-  const Int_t kNcutStepsTrack = AliHFEcuts::kNcutStepsMCTrack + kNcutStepsESDtrack;
-  const Int_t kNvar   = 4;
-  //number of variables on the grid:pt,eta, phi, charge
-  const Double_t kPtbound[2] = {0.1, 10.};
-  const Double_t kEtabound[2] = {-0.8, 0.8};
-  const Double_t kPhibound[2] = {0., 2. * TMath::Pi()};
-
-  //arrays for the number of bins in each dimension
-  Int_t iBin[kNvar];
-  iBin[0] = 40; // bins in pt
-  iBin[1] =  8; // bins in eta 
-  iBin[2] = 18; // bins in phi
-  iBin[3] =  2; // bins in charge
-
-  //arrays for lower bounds :
-  Double_t* binEdges[kNvar];
-  binEdges[0] = AliHFEtools::MakeLogarithmicBinning(iBin[0], kPtbound[0], kPtbound[1]);
-  binEdges[1] = AliHFEtools::MakeLinearBinning(iBin[1], kEtabound[0], kEtabound[1]);
-  binEdges[2] = AliHFEtools::MakeLinearBinning(iBin[2], kPhibound[0], kPhibound[1]);
-  binEdges[3] = AliHFEtools::MakeLinearBinning(iBin[3], -1.1, 1.1); // Numeric precision
-
-  //------------------------------------------------
-  //     one "container" for MC+ESD+Data          
-  //----------pure MC track-------------------------
-  // 0: MC generated
-  // 1: MC pion total  ---- be careful!!!!
-  // 2: MC electrons total
-  // 3: MC electrons in acceptance 
-  //-------ESD track with MC info-------------------
-  // 4: ESD track with MC: no cut
-  // 5: ESD track with MC: cut on kine its tpc
-  // 6: ESD track with MC: rec prim
-  // 7: ESD track with MC: hfe cuts its
-  // 8: ESD track with MC: hfe cuts trd
-  // 9: ESD track with MC: hfe pid 
-  //-----------data track---------------------------
-  // 10: DATA track wo MC: no cut
-  // 11: DATA track wo MC: cut on kine its tpc
-  // 12: DATA track wo MC: rec prim
-  // 13: DATA track wo MC: hfe cuts its
-  // 14: DATA track wo MC: hfe cuts trd
-  // 15: DATA track wo MC: hfe pid 
-  //------------------------------------------------
-
-  AliCFContainer* container = new AliCFContainer("deTrackContainer", "Container for tracks", 
-                                                (1 + kNcutStepsTrack + kNcutStepsESDtrack), kNvar, iBin);
-  
-  //setting the bin limits
-  for(Int_t ivar = 0; ivar < kNvar; ivar++){
-    container -> SetBinLimits(ivar, binEdges[ivar]);
-  }
-  fDeCFM->SetParticleContainer(container);
-}
-
-
-//____________________________________________________________
-void AliAnalysisTaskDisplacedElectrons::MakeEventContainer(){
-  //
-  // Create the event container for the correction framework and link it
-  //
-  
-  // event container
-  // 0: MC event
-  // 1: ESD event
-
-  const Int_t kNvar = 1;  // number of variables on the grid: number of tracks per event
-  const Double_t kNTrackBound[2] = {-0.5, 200.5};
-  const Int_t kNBins = 201;
-
-  AliCFContainer *evCont = new AliCFContainer("deEventContainer", "Container for DE events", AliHFEcuts::kNcutStepsEvent, kNvar, &kNBins);
-
-  Double_t trackBins[kNBins];
-  for(Int_t ibin = 0; ibin < kNBins; ibin++) trackBins[ibin] = kNTrackBound[0] + static_cast<Double_t>(ibin);
-  evCont->SetBinLimits(0,trackBins);
-
-  fDeCFM->SetEventContainer(evCont);
-
-}
-
-
-
-//__________________________________________________________
-void AliAnalysisTaskDisplacedElectrons::AddPIDdetector(TString detector){
-  //
-  // Adding PID detector to the task
-  //
-  if(!fDePIDdetectors.Length()) 
-    fDePIDdetectors = detector;
-  else
-    fDePIDdetectors += ":" + detector;
-}
-
-
-
-//____________________________________________________________
-AliAnalysisTaskDisplacedElectrons::AliLabelContainer::AliLabelContainer(Int_t capacity):
-  fContainer(NULL),
-  fBegin(NULL),
-  fEnd(NULL),
-  fLast(NULL),
-  fCurrent(NULL)
-{
-  //
-  // Default constructor
-  //
-  fContainer = new Int_t[capacity];
-  fBegin = &fContainer[0];
-  fEnd = &fContainer[capacity - 1];
-  fLast = fCurrent = fBegin;
-}
-
-//____________________________________________________________
-Bool_t AliAnalysisTaskDisplacedElectrons::AliLabelContainer::Append(Int_t label){
-  //
-  // Add Label to the container
-  //
-  if(fLast > fEnd) return kFALSE;
-  *fLast++ = label;
-  return kTRUE;
-}
-
-//____________________________________________________________
-Bool_t AliAnalysisTaskDisplacedElectrons::AliLabelContainer::Find(Int_t label) const {
-  //
-  // Find track in the list of labels
-  //
-  for(Int_t *entry = fBegin; entry <= fLast; entry++) 
-    if(*entry == label) return kTRUE;
-  return kFALSE;
-}
-
-//____________________________________________________________
-Int_t AliAnalysisTaskDisplacedElectrons::AliLabelContainer::Next() { 
-  //
-  // Mimic iterator
-  //
-  if(fCurrent > fLast) return -1; 
-  fCurrent++;
-  return *fCurrent;
-}
diff --git a/PWGHF/hfe/AliAnalysisTaskDisplacedElectrons.h b/PWGHF/hfe/AliAnalysisTaskDisplacedElectrons.h
deleted file mode 100644 (file)
index 713fdf3..0000000
+++ /dev/null
@@ -1,158 +0,0 @@
-/**************************************************************************
-* 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.                  *
-**************************************************************************/
-//
-// Analysis task: 
-// study displaced electrons from beauty and charm 
-// with cut on impact parameters in various pT bins
-// 
-//
-// Authors:
-//  Hongyan Yang <hongyan@physi.uni-heidelberg.de>
-//  Carlo Bombonati <Carlo.Bombonati@cern.ch>
-// 
-
-
-
-#ifndef ALIANALYSISTASKDISPLACEDELECTRONS_H
-#define ALIANALYSISTASKDISPLACEDELECTRONS_H
-
-#ifndef ALIANALYSISTASKSE_H
-#include "AliAnalysisTaskSE.h"
-#endif
-
-#ifndef ROOT_THnSparse
-#include <THnSparse.h>
-#endif
-
-class TH1I; 
-class TH1F;
-class TList;
-class AliLog;
-
-class AliCFManager;
-class AliESDEvent;
-class AliESDtrackCuts;
-class AliMCEvent;
-class AliVParticle;
-
-class AliStack;
-
-class AliHFEpid;
-class AliHFEcuts;
-class AliHFEdisplacedElectrons;
-
-class AliAnalysisTaskDisplacedElectrons : public AliAnalysisTaskSE{
- public:
-
-  typedef enum{
-    kPostProcess = 0,
-    kDisplacedElectrons = 1, 
-    kCorrection = 2,
-    kDePidQA = 3
-  }Switches_t;
-
-  enum{
-    kHasMCdata = BIT(19),
-    kAODanalysis = BIT(20)
-  };
-  
-  AliAnalysisTaskDisplacedElectrons();
-  AliAnalysisTaskDisplacedElectrons(const char * name);
-  AliAnalysisTaskDisplacedElectrons(const AliAnalysisTaskDisplacedElectrons &ref);
-  AliAnalysisTaskDisplacedElectrons& operator=(const AliAnalysisTaskDisplacedElectrons &ref);
-  virtual ~AliAnalysisTaskDisplacedElectrons();
-  
-  virtual void UserCreateOutputObjects();
-  virtual void UserExec(Option_t *);
-  //  virtual void ConnectInputData(Option_t *);
-  virtual void Terminate(Option_t *);
-
-  void PrintStatus() const;
-  
-  Bool_t GetPlugin(Int_t plug) const { return TESTBIT(fDePlugins, plug); };
-  void SwitchOnPlugin(Int_t plug);
-
-  void SetHFECuts(AliHFEcuts * const cuts) { fDeCuts = cuts; };
-  void SetNclustersITS(Int_t nITSclusters){fNminITSCluster = nITSclusters;};
-  void SetMinPrimVtxContrib(Int_t nPrimVtxContrib){fNminPrimVtxContrib = nPrimVtxContrib;};
-  void SetPIDdetectors(Char_t * const detectors){ fDePIDdetectors = detectors; };
-  void SetPIDStrategy(UInt_t strategy) { fDePIDstrategy = strategy; };
-  void SetDBLevel(UInt_t debugLevel) { fDeDebugLevel = debugLevel; };
-  void AddPIDdetector(TString detector); 
-  Bool_t IsAODanalysis() const { return TestBit(kAODanalysis); };
-  Bool_t IsESDanalysis() const { return !TestBit(kAODanalysis); };
-  Bool_t HasMCData() const { return TestBit(kHasMCdata); }
-  void SetHasMCData(Bool_t hasMC = kTRUE) { SetBit(kHasMCdata, hasMC); };
-  
-  void SetAODAnalysis() { SetBit(kAODanalysis, kTRUE); };
-  void SetESDAnalysis() { SetBit(kAODanalysis, kFALSE); };
-
-  void ProcessMC();
-  void ProcessESD();
-  void ProcessData();
-  
-
-  
- private:
-  
-  class AliLabelContainer{
-  public:
-    AliLabelContainer(Int_t capacity);
-    ~AliLabelContainer() {delete[] fContainer; };
-    
-    Bool_t Append(Int_t label);
-    Bool_t Find(Int_t Label) const;
-    Int_t Next();
-    void ResetIterator(){ fCurrent = fBegin; }
-    
-  private:
-    AliLabelContainer(const AliLabelContainer &);
-    AliLabelContainer &operator=(const AliLabelContainer &);
-    Int_t *fContainer;    // the Container for the labels
-    Int_t *fBegin;        // Pointer to the first entry
-    Int_t *fEnd;          // Pointer to the end of the container
-    Int_t *fLast;         // Pointer to the last entry
-    Int_t *fCurrent;      // Current entry to mimic an iterator
-  };
-    
-  void MakeParticleContainer();
-  void MakeEventContainer();
-
-  UInt_t fDeDebugLevel;                  // debug level
-  Int_t fNminITSCluster;                 // number of clusters in ITS
-  Int_t fNminPrimVtxContrib;             // number of ncontributor in ITS for prim vtx
-  TString fDePIDdetectors;                // Detectors for Particle Identification
-  UInt_t fDePIDstrategy;                  // PID Strategy
-
-  UShort_t fDePlugins;                    // Enabled Plugins    
-
-  AliHFEcuts *fDeCuts;                    // Cut Collection
-  AliHFEpid *fDePID;                      //! PID method
-  AliCFManager *fDeCFM;                   //! Correction Framework Manager
-  AliHFEdisplacedElectrons *fDisplacedElectrons;        //! HFE displaced Electrons pointer 
-                                
-  TH1I *fDeNEvents;                       //! counter for the number of Events
-  TH1F *fElectronsMcPt;                   //! pt distribution of MC electrons (mcpid)
-  TH1F *fElectronsEsdPt;                  //! pt distribution of ESD electrons (hfepid)
-  TH1F *fElectronsDataPt;                 //! pt distribution of DATA electrons (hfepid)
-  TList *fDeCorrection;                   //! Container for correction  Outpu  
-  TList *fDeQA;                          //! container for the PID qa 
-  TList *fHistDisplacedElectrons;                      //! list of outputs
-  ClassDef(AliAnalysisTaskDisplacedElectrons, 1);      // The DisplacedElectrons Analysis Task
-};
-#endif
-
diff --git a/PWGHF/hfe/AliAnalysisTaskHFEFlowData.cxx b/PWGHF/hfe/AliAnalysisTaskHFEFlowData.cxx
deleted file mode 100644 (file)
index d013a12..0000000
+++ /dev/null
@@ -1,736 +0,0 @@
-/**************************************************************************\r
-* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
-*                                                                        *\r
-* Author: The ALICE Off-line Project.                                    *\r
-* Contributors are mentioned in the code where appropriate.              *\r
-*                                                                        *\r
-* Permission to use, copy, modify and distribute this software and its   *\r
-* documentation strictly for non-commercial purposes is hereby granted   *\r
-* without fee, provided that the above copyright notice appears in all   *\r
-* copies and that both the copyright notice and this permission notice   *\r
-* appear in the supporting documentation. The authors make no claims     *\r
-* about the suitability of this software for any purpose. It is          *\r
-* provided "as is" without express or implied warranty.                  *\r
-**************************************************************************/\r
-//\r
-// Flow task\r
-// \r
-// Authors:\r
-//   Raphaelle Bailhache <R.Bailhache@gsi.de>\r
-//\r
-#include "TROOT.h"\r
-#include "TH1D.h"\r
-#include "TH2D.h"\r
-#include "TChain.h"\r
-#include "TVector2.h"\r
-#include "THnSparse.h"\r
-#include "TMath.h"\r
-#include "TRandom3.h"\r
-#include "TProfile.h"\r
-#include "TProfile2D.h"\r
-\r
-#include "AliVEventHandler.h"\r
-#include "AliAnalysisTaskSE.h"\r
-#include "AliAnalysisManager.h"\r
-\r
-#include "AliVEvent.h"\r
-#include "AliESDInputHandler.h"\r
-#include "AliMCEvent.h"\r
-#include "AliESD.h"\r
-#include "AliESDEvent.h"\r
-#include "AliPIDResponse.h"\r
-#include "AliESDVZERO.h"\r
-#include "AliESDUtils.h"\r
-#include "AliMCParticle.h"\r
-#include "AliVTrack.h"\r
-#include "AliAODTrack.h"\r
-\r
-#include "AliFlowCandidateTrack.h"\r
-#include "AliFlowEvent.h"\r
-#include "AliFlowTrackCuts.h"\r
-#include "AliFlowVector.h"\r
-#include "AliFlowCommonConstants.h"\r
-\r
-#include "AliHFEcuts.h"\r
-#include "AliHFEpid.h"\r
-#include "AliHFEpidQAmanager.h"\r
-#include "AliHFEtools.h"\r
-#include "AliHFEVZEROEventPlane.h"\r
-\r
-#include "AliCentrality.h"\r
-#include "AliEventplane.h"\r
-#include "AliAnalysisTaskHFEFlowData.h"\r
-\r
-\r
-//____________________________________________________________________\r
-AliAnalysisTaskHFEFlowData::AliAnalysisTaskHFEFlowData() :\r
-  AliAnalysisTaskSE(),\r
-  fListHist(0x0), \r
-  fAODAnalysis(kFALSE),\r
-  fUseFlagAOD(kFALSE),\r
-  fApplyCut(kTRUE),\r
-  fFlags(1<<4),\r
-  fVZEROEventPlane(kFALSE),\r
-  fVZEROEventPlaneA(kFALSE),\r
-  fVZEROEventPlaneC(kFALSE),\r
-  fSubEtaGapTPC(kFALSE),\r
-  fEtaGap(0.0),\r
-  fDebugLevel(0),\r
-  fHFECuts(0),\r
-  fPID(0),\r
-  fPIDqa(0),\r
-  fHistEV(0),\r
-  fEventPlane(0x0),\r
-  fCosResabc(0x0),\r
-  fCosRes(0x0),\r
-  fDeltaPhiMaps(0x0),\r
-  fCosPhiMaps(0x0)\r
-{\r
-  // Constructor\r
-\r
-  \r
-}\r
-//______________________________________________________________________________\r
-AliAnalysisTaskHFEFlowData:: AliAnalysisTaskHFEFlowData(const char *name) :\r
-  AliAnalysisTaskSE(name),\r
-  fListHist(0x0),\r
-  fAODAnalysis(kFALSE),\r
-  fUseFlagAOD(kFALSE),\r
-  fApplyCut(kTRUE),\r
-  fFlags(1<<4), \r
-  fVZEROEventPlane(kFALSE),\r
-  fVZEROEventPlaneA(kFALSE),\r
-  fVZEROEventPlaneC(kFALSE),\r
-  fSubEtaGapTPC(kFALSE),\r
-  fEtaGap(0.0),\r
-  fDebugLevel(0),\r
-  fHFECuts(0),\r
-  fPID(0),\r
-  fPIDqa(0),\r
-  fHistEV(0),\r
-  fEventPlane(0x0),\r
-  fCosResabc(0x0),\r
-  fCosRes(0x0),\r
-  fDeltaPhiMaps(0x0),\r
-  fCosPhiMaps(0x0)\r
-{\r
-  //\r
-  // named ctor\r
-  //\r
-  \r
-  fPID = new AliHFEpid("hfePid");\r
-  fPIDqa = new AliHFEpidQAmanager;\r
-\r
-  DefineInput(0,TChain::Class());\r
-  DefineOutput(1, TList::Class());\r
-   \r
-}\r
-//____________________________________________________________\r
-AliAnalysisTaskHFEFlowData::AliAnalysisTaskHFEFlowData(const AliAnalysisTaskHFEFlowData &ref):\r
-  AliAnalysisTaskSE(ref),\r
-  fListHist(0x0),\r
-  fAODAnalysis(ref.fAODAnalysis), \r
-  fUseFlagAOD(ref.fUseFlagAOD),\r
-  fApplyCut(ref.fApplyCut),\r
-  fFlags(ref.fFlags),\r
-  fVZEROEventPlane(ref.fVZEROEventPlane),\r
-  fVZEROEventPlaneA(ref.fVZEROEventPlaneA),\r
-  fVZEROEventPlaneC(ref.fVZEROEventPlaneC),\r
-  fSubEtaGapTPC(ref.fSubEtaGapTPC),\r
-  fEtaGap(ref.fEtaGap),\r
-  fDebugLevel(ref.fDebugLevel),\r
-  fHFECuts(0),\r
-  fPID(0),\r
-  fPIDqa(0),\r
-  fHistEV(0),\r
-  fEventPlane(0x0),\r
-  fCosResabc(0x0),\r
-  fCosRes(0x0),\r
-  fDeltaPhiMaps(0x0),\r
-  fCosPhiMaps(0x0)\r
-{\r
-  //\r
-  // Copy Constructor\r
-  //\r
-  ref.Copy(*this);\r
-}\r
-\r
-//____________________________________________________________\r
-AliAnalysisTaskHFEFlowData &AliAnalysisTaskHFEFlowData::operator=(const AliAnalysisTaskHFEFlowData &ref){\r
-  //\r
-  // Assignment operator\r
-  //\r
-  if(this == &ref) \r
-    ref.Copy(*this);\r
-  return *this;\r
-}\r
-\r
-//____________________________________________________________\r
-void AliAnalysisTaskHFEFlowData::Copy(TObject &o) const {\r
-  // \r
-  // Copy into object o\r
-  //\r
-  AliAnalysisTaskHFEFlowData &target = dynamic_cast<AliAnalysisTaskHFEFlowData &>(o);\r
-  target.fAODAnalysis = fAODAnalysis;\r
-  target.fUseFlagAOD = fUseFlagAOD;\r
-  target.fApplyCut = fApplyCut;\r
-  target.fFlags = fFlags;\r
-  target.fVZEROEventPlane = fVZEROEventPlane;\r
-  target.fVZEROEventPlaneA = fVZEROEventPlaneA;\r
-  target.fVZEROEventPlaneC = fVZEROEventPlaneC;\r
-  target.fSubEtaGapTPC = fSubEtaGapTPC;\r
-  target.fEtaGap = fEtaGap;\r
-  target.fDebugLevel = fDebugLevel;\r
-  target.fHFECuts = fHFECuts;\r
-  target.fPID = fPID;\r
-  target.fPIDqa = fPIDqa;\r
-  \r
-}\r
-//____________________________________________________________\r
-AliAnalysisTaskHFEFlowData::~AliAnalysisTaskHFEFlowData(){\r
-  //\r
-  // Destructor\r
-  //\r
-  if(fListHist) delete fListHist;\r
-  if(fHFECuts) delete fHFECuts;\r
-  if(fPID) delete fPID;\r
-  if(fPIDqa) delete fPIDqa;\r
\r
-\r
-}\r
-//________________________________________________________________________\r
-void AliAnalysisTaskHFEFlowData::UserCreateOutputObjects()\r
-{\r
-\r
-  //********************\r
-  // Create histograms\r
-  //********************\r
-\r
-  //**************\r
-  // Cuts\r
-  //**************\r
-\r
-  AliDebug(1,"AliAnalysisTaskHFEFlowData: create output objects");\r
-\r
-  // HFE cuts\r
-\r
-  if(!fHFECuts){\r
-    fHFECuts = new AliHFEcuts;\r
-    fHFECuts->CreateStandardCuts();\r
-  }\r
-  fHFECuts->Initialize();\r
-  if(fAODAnalysis) fHFECuts->SetAOD();  \r
-\r
-  AliDebug(1,"AliAnalysisTaskHFEFlowData: HFE cuts initialize");\r
-\r
-  // PID HFE\r
-  //fPID->SetHasMCData(HasMCData());\r
-  if(!fPID->GetNumberOfPIDdetectors()) fPID->AddDetector("TPC", 0);\r
-  fPID->InitializePID();\r
-  fPIDqa->Initialize(fPID);\r
-  fPID->SortDetectors();\r
-\r
-  AliDebug(1,"AliAnalysisTaskHFEFlowData: pid and pidqa");\r
-  \r
-  //**************************\r
-  // Bins for the THnSparse\r
-  //**************************\r
-\r
-  Int_t nBinsPt = 24;\r
-  Double_t binLimPt[25] = {0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.1, 1.2,\r
-                          1.3, 1.4, 1.5, 1.75, 2., 2.25, 2.5, 3., 3.5, 4., 5.,\r
-                          6.};\r
-  \r
-  Int_t nBinsEtaLess = 2;\r
-  Double_t minEta = -0.8;\r
-  Double_t maxEta = 0.8;\r
-  Double_t binLimEtaLess[nBinsEtaLess+1];\r
-  for(Int_t i=0; i<=nBinsEtaLess; i++) binLimEtaLess[i]=(Double_t)minEta + (maxEta-minEta)/nBinsEtaLess*(Double_t)i ;\r
\r
-  Int_t nBinsCos = 50;\r
-  Double_t minCos = -1.0;\r
-  Double_t maxCos = 1.0;\r
-  Double_t binLimCos[nBinsCos+1];\r
-  for(Int_t i=0; i<=nBinsCos; i++) binLimCos[i]=(Double_t)minCos + (maxCos-minCos)/nBinsCos*(Double_t)i ;\r
\r
-  Int_t nBinsC = 11;\r
-  Double_t minC = 0.0;\r
-  Double_t maxC = 11.0;\r
-  Double_t binLimC[nBinsC+1];\r
-  for(Int_t i=0; i<=nBinsC; i++) binLimC[i]=(Double_t)minC + (maxC-minC)/nBinsC*(Double_t)i ;\r
-\r
-  Int_t nBinsCMore = 20;\r
-  Double_t minCMore = 0.0;\r
-  Double_t maxCMore = 20.0;\r
-  Double_t binLimCMore[nBinsCMore+1];\r
-  for(Int_t i=0; i<=nBinsCMore; i++) binLimCMore[i]=(Double_t)minCMore + (maxCMore-minCMore)/nBinsCMore*(Double_t)i ;\r
-\r
-  Int_t nBinsPhi = 25;\r
-  Double_t minPhi = 0.0;\r
-  Double_t maxPhi = TMath::Pi();\r
-  Double_t binLimPhi[nBinsPhi+1];\r
-  for(Int_t i=0; i<=nBinsPhi; i++) {\r
-    binLimPhi[i]=(Double_t)minPhi + (maxPhi-minPhi)/nBinsPhi*(Double_t)i ;\r
-  }\r
-\r
-  Int_t nBinsCharge = 2;\r
-  Double_t minCharge = -1.0;\r
-  Double_t maxCharge = 1.0;\r
-  Double_t binLimCharge[nBinsCharge+1];\r
-  for(Int_t i=0; i<=nBinsCharge; i++) binLimCharge[i]=(Double_t)minCharge + (maxCharge-minCharge)/nBinsCharge*(Double_t)i ;\r
-  \r
-  AliDebug(1,"AliAnalysisTaskHFEFlowData: array of bins");\r
-\r
-  //******************\r
-  // Histograms\r
-  //******************\r
-    \r
-  fListHist = new TList();\r
-  fListHist->SetOwner();\r
-\r
-  AliDebug(1,"AliAnalysisTaskHFEFlowData: list created");\r
-  \r
-  // Histos\r
-  fHistEV = new TH2D("fHistEV", "events", 3, 0, 3, 3, 0,3);\r
-  \r
-  AliDebug(1,"AliAnalysisTaskHFEFlowData: fHistEv");\r
-\r
-  // Event plane as function of phiep, centrality\r
-  const Int_t nDima=5;\r
-  Int_t nBina[nDima] = {nBinsPhi,nBinsPhi,nBinsPhi,nBinsPhi,nBinsC};\r
-  fEventPlane = new THnSparseF("EventPlane","EventPlane",nDima,nBina);\r
-  fEventPlane->SetBinEdges(0,binLimPhi);\r
-  fEventPlane->SetBinEdges(1,binLimPhi);\r
-  fEventPlane->SetBinEdges(2,binLimPhi);\r
-  fEventPlane->SetBinEdges(3,binLimPhi);\r
-  fEventPlane->SetBinEdges(4,binLimC);\r
-  fEventPlane->Sumw2();\r
-\r
-  AliDebug(1,"AliAnalysisTaskHFEFlowData: fEventPlane");\r
-  \r
-  // Resolution cosres_abc centrality\r
-  const Int_t nDimfbis=4;\r
-  Int_t nBinfbis[nDimfbis] = {nBinsCos,nBinsCos,nBinsCos,nBinsCMore};\r
-  fCosResabc = new THnSparseF("CosRes_abc","CosRes_abc",nDimfbis,nBinfbis);\r
-  fCosResabc->SetBinEdges(0,binLimCos);\r
-  fCosResabc->SetBinEdges(1,binLimCos);\r
-  fCosResabc->SetBinEdges(2,binLimCos);\r
-  fCosResabc->SetBinEdges(3,binLimCMore);\r
-  fCosResabc->Sumw2();\r
-\r
-  AliDebug(1,"AliAnalysisTaskHFEFlowData: fCosResabc");\r
-\r
-  // Resolution cosres centrality\r
-  const Int_t nDimf=2;\r
-  Int_t nBinf[nDimf] = {nBinsCos, nBinsCMore};\r
-  fCosRes = new THnSparseF("CosRes","CosRes",nDimf,nBinf);\r
-  fCosRes->SetBinEdges(0,binLimCos);\r
-  fCosRes->SetBinEdges(1,binLimCMore);\r
-  fCosRes->Sumw2();\r
-\r
-  AliDebug(1,"AliAnalysisTaskHFEFlowData: fCosRes");\r
-  \r
-  // Maps delta phi\r
-  const Int_t nDimg=5;\r
-  Int_t nBing[nDimg] = {nBinsPhi,nBinsC,nBinsPt, nBinsCharge,nBinsEtaLess};\r
-  fDeltaPhiMaps = new THnSparseF("DeltaPhiMaps","DeltaPhiMaps",nDimg,nBing);\r
-  fDeltaPhiMaps->SetBinEdges(0,binLimPhi);\r
-  fDeltaPhiMaps->SetBinEdges(1,binLimC);\r
-  fDeltaPhiMaps->SetBinEdges(2,binLimPt);\r
-  fDeltaPhiMaps->SetBinEdges(3,binLimCharge);\r
-  fDeltaPhiMaps->SetBinEdges(4,binLimEtaLess);\r
-  fDeltaPhiMaps->Sumw2();  \r
-\r
-  AliDebug(1,"AliAnalysisTaskHFEFlowData: fDeltaPhiMaps");\r
-\r
-  // Maps cos phi\r
-  const Int_t nDimh=5;\r
-  Int_t nBinh[nDimh] = {nBinsCos,nBinsC,nBinsPt,nBinsCharge,nBinsEtaLess};\r
-  fCosPhiMaps = new THnSparseF("CosPhiMaps","CosPhiMaps",nDimh,nBinh);\r
-  fCosPhiMaps->SetBinEdges(0,binLimCos);\r
-  fCosPhiMaps->SetBinEdges(1,binLimC);\r
-  fCosPhiMaps->SetBinEdges(2,binLimPt);\r
-  fCosPhiMaps->SetBinEdges(3,binLimCharge);\r
-  fCosPhiMaps->SetBinEdges(4,binLimEtaLess);\r
-  fCosPhiMaps->Sumw2();\r
-\r
-  AliDebug(1,"AliAnalysisTaskHFEFlowData: fCosPhiMaps");\r
-\r
-  //**************************\r
-  // Add to the list\r
-  //******************************\r
-\r
-  //fListHist->Add(qaCutsRP);\r
-  fListHist->Add(fPIDqa->MakeList("HFEpidQA"));\r
-  fListHist->Add(fHistEV);\r
-  fListHist->Add(fEventPlane);\r
-  fListHist->Add(fCosRes);\r
-  fListHist->Add(fCosResabc);\r
-  fListHist->Add(fDeltaPhiMaps);\r
-  fListHist->Add(fCosPhiMaps);\r
-\r
-  AliDebug(1,"AliAnalysisTaskHFEFlowData: added to the list");\r
-  \r
-  \r
-  PostData(1, fListHist);\r
-\r
-  AliDebug(1,"AliAnalysisTaskHFEFlowData: Post Data");\r
-\r
-}\r
-   \r
-//________________________________________________________________________\r
-void AliAnalysisTaskHFEFlowData::UserExec(Option_t */*option*/)\r
-{\r
-  //\r
-  // Loop over event\r
-  //\r
-\r
-  AliDebug(1,"AliAnalysisTaskHFEFlowData: UserExec");\r
-   \r
-  Float_t cntr = 0.0;\r
-  Double_t binct = 11.5;\r
-  Double_t binctMore = 20.5;\r
-  Float_t binctt = -1.0;\r
-  \r
-  Double_t valuensparsea[5];\r
-  Double_t valuensparsefbis[4];\r
-  Double_t valuensparsef[2];\r
-  Double_t valuensparseg[5];\r
-  Double_t valuensparseh[5];\r
-\r
-  AliDebug(1, "Variable initialized");\r
-\r
-  \r
-  /////////////////\r
-  // centrality\r
-  /////////////////\r
-  \r
-  //AliESDEvent *esd = dynamic_cast<AliESDEvent*>(InputEvent());\r
-  //if(!esd) return;\r
-  AliCentrality *centrality = fInputEvent->GetCentrality();\r
-  //printf("Got the centrality\n");\r
-  if(!centrality) {\r
-    PostData(1, fListHist);\r
-    return;\r
-  }\r
-  cntr = centrality->GetCentralityPercentile("V0M");\r
-  if((0.0< cntr) && (cntr<5.0)) binct = 0.5;\r
-  if((5.0< cntr) && (cntr<10.0)) binct = 1.5;\r
-  if((10.0< cntr) && (cntr<20.0)) binct = 2.5;\r
-  if((20.0< cntr) && (cntr<30.0)) binct = 3.5;\r
-  if((30.0< cntr) && (cntr<40.0)) binct = 4.5;\r
-  if((40.0< cntr) && (cntr<50.0)) binct = 5.5;\r
-  if((50.0< cntr) && (cntr<60.0)) binct = 6.5;\r
-  if((60.0< cntr) && (cntr<70.0)) binct = 7.5;\r
-  if((70.0< cntr) && (cntr<80.0)) binct = 8.5;\r
-  if((80.0< cntr) && (cntr<90.0)) binct = 9.5;\r
-  if((90.0< cntr) && (cntr<100.0)) binct = 10.5;\r
-  \r
-  if((0.< cntr) && (cntr < 20.)) binctt = 0.5;\r
-  if((20.< cntr) && (cntr < 40.)) binctt = 1.5;\r
-  if((40.< cntr) && (cntr < 80.)) binctt = 2.5;\r
-\r
-  if((0.0< cntr) && (cntr<5.0)) binctMore = 0.5;\r
-  if((5.0< cntr) && (cntr<10.0)) binctMore = 1.5;\r
-  if((10.0< cntr) && (cntr<15.0)) binctMore = 2.5;\r
-  if((15.0< cntr) && (cntr<20.0)) binctMore = 3.5;\r
-  if((20.0< cntr) && (cntr<25.0)) binctMore = 4.5;\r
-  if((25.0< cntr) && (cntr<30.0)) binctMore = 5.5;\r
-  if((30.0< cntr) && (cntr<35.0)) binctMore = 6.5;\r
-  if((35.0< cntr) && (cntr<40.0)) binctMore = 7.5;\r
-  if((40.0< cntr) && (cntr<45.0)) binctMore = 8.5;\r
-  if((45.0< cntr) && (cntr<50.0)) binctMore = 9.5;\r
-  if((50.0< cntr) && (cntr<55.0)) binctMore = 10.5;\r
-  if((55.0< cntr) && (cntr<60.0)) binctMore = 11.5;\r
-  if((60.0< cntr) && (cntr<65.0)) binctMore = 12.5;\r
-  if((65.0< cntr) && (cntr<70.0)) binctMore = 13.5;\r
-  if((70.0< cntr) && (cntr<75.0)) binctMore = 14.5;\r
-  if((75.0< cntr) && (cntr<80.0)) binctMore = 15.5;\r
-  if((80.0< cntr) && (cntr<85.0)) binctMore = 16.5;\r
-  if((85.0< cntr) && (cntr<90.0)) binctMore = 17.5;\r
-  if((90.0< cntr) && (cntr<95.0)) binctMore = 18.5;\r
-  if((95.0< cntr) && (cntr<100.0)) binctMore = 19.5;\r
-\r
-  \r
-  if(binct > 11.0) {\r
-    PostData(1, fListHist);\r
-    return;\r
-  }\r
\r
-  AliDebug(1, "Centrality");\r
-\r
-  // centrality\r
-  valuensparsea[4] = binct;  \r
-  valuensparsef[1] = binctMore;  \r
-  valuensparsefbis[3] = binctMore;  \r
-  valuensparseg[1] = binct;\r
-  valuensparseh[1] = binct; \r
-  \r
-  //////////////////////\r
-  // run number\r
-  //////////////////////\r
-\r
-  Int_t runnumber = fInputEvent->GetRunNumber();\r
-  \r
-  if(!fPID->IsInitialized()){\r
-    fPID->InitializePID(runnumber);\r
-  }\r
-\r
-  AliDebug(1, "Run number");\r
-\r
-  //////////\r
-  // PID\r
-  //////////\r
\r
-  AliPIDResponse *pidResponse = fInputHandler->GetPIDResponse();\r
-  if(!pidResponse){\r
-    PostData(1, fListHist);\r
-    return;\r
-  }\r
-  fPID->SetPIDResponse(pidResponse);\r
-\r
-  AliDebug(1, "PID");\r
-\r
-  fHistEV->Fill(binctt,0.0);\r
\r
-  AliDebug(1, "fHistEv");\r
-\r
-  //////////////////\r
-  // Event cut\r
-  //////////////////\r
-  if(!fHFECuts->CheckEventCuts("fEvRecCuts", fInputEvent)) {\r
-    PostData(1, fListHist);\r
-    return;\r
-  }\r
-\r
-  AliDebug(1, "Event cut");\r
-\r
-  fHistEV->Fill(binctt,1.0);\r
-\r
-  ////////////////////////////////////  \r
-  // First method event plane\r
-  ////////////////////////////////////\r
-\r
-  AliEventplane* vEPa = fInputEvent->GetEventplane();\r
-  Float_t eventPlanea = 0.0;\r
-  Float_t eventPlaneTPC = 0.0;\r
-  Float_t eventPlaneV0A = 0.0;\r
-  Float_t eventPlaneV0C = 0.0;\r
-  Float_t eventPlaneV0 = 0.0;\r
-  TVector2 *standardQ = 0x0;\r
-  TVector2 *qsub1a = 0x0;\r
-  TVector2 *qsub2a = 0x0;\r
-\r
-  // V0\r
-\r
-  eventPlaneV0 = TVector2::Phi_0_2pi(vEPa->GetEventplane("V0", fInputEvent,2));\r
-  if(eventPlaneV0 > TMath::Pi()) eventPlaneV0 = eventPlaneV0 - TMath::Pi();\r
-  eventPlaneV0A = TVector2::Phi_0_2pi(vEPa->GetEventplane("V0A", fInputEvent,2));\r
-  if(eventPlaneV0A > TMath::Pi()) eventPlaneV0A = eventPlaneV0A - TMath::Pi();\r
-  eventPlaneV0C = TVector2::Phi_0_2pi(vEPa->GetEventplane("V0C", fInputEvent,2));\r
-  if(eventPlaneV0C > TMath::Pi()) eventPlaneV0C = eventPlaneV0C - TMath::Pi();\r
-  \r
-  AliDebug(1, "V0 event plane");\r
-  \r
-  // TPC\r
-\r
-  standardQ = vEPa->GetQVector(); \r
-  Double_t qx = -1.0;\r
-  Double_t qy = -1.0;\r
-  if(standardQ) {\r
-    qx = standardQ->X();\r
-    qy = standardQ->Y();\r
-  }  \r
-  TVector2 qVectorfortrack;\r
-  qVectorfortrack.Set(qx,qy);\r
-  eventPlaneTPC = TVector2::Phi_0_2pi(qVectorfortrack.Phi())/2.; \r
-\r
-  AliDebug(1, "TPC event plane");\r
-\r
-  // Choose the one used for v2\r
-\r
-  if(fVZEROEventPlane) eventPlanea = eventPlaneV0;\r
-  if(fVZEROEventPlaneA) eventPlanea = eventPlaneV0A;\r
-  if(fVZEROEventPlaneC) eventPlanea = eventPlaneV0C;\r
-  if(!fVZEROEventPlane) eventPlanea = eventPlaneTPC;\r
-\r
-  Float_t eventPlanesub1a = -100.0;\r
-  Float_t eventPlanesub2a = -100.0;\r
-  Double_t diffsub1sub2a = -100.0;\r
-  Double_t diffsubasubb = -100.0;\r
-  Double_t diffsubasubc = -100.0;\r
-  Double_t diffsubbsubc = -100.0;\r
-  \r
-  diffsubasubb = TMath::Cos(2.*(eventPlaneV0A - eventPlaneV0C));\r
-  diffsubasubc = TMath::Cos(2.*(eventPlaneV0A - eventPlaneTPC));\r
-  diffsubbsubc = TMath::Cos(2.*(eventPlaneV0C - eventPlaneTPC));\r
-  \r
-  qsub1a = vEPa->GetQsub1();\r
-  qsub2a = vEPa->GetQsub2();\r
-  if(qsub1a) eventPlanesub1a = TVector2::Phi_0_2pi(qsub1a->Phi())/2.;\r
-  if(qsub2a) eventPlanesub2a = TVector2::Phi_0_2pi(qsub2a->Phi())/2.;\r
-  if(qsub1a && qsub2a) {\r
-    diffsub1sub2a = TMath::Cos(2.*TVector2::Phi_0_2pi(qsub1a->Phi()/2.- qsub2a->Phi()/2.));\r
-  }\r
-\r
-  AliDebug(1, "Diff");\r
-  \r
-  /////////////////////////////////////////////////////////\r
-  // Cut for event with event plane reconstructed by all\r
-  ////////////////////////////////////////////////////////\r
-  \r
-  if((!standardQ) || (!qsub1a) || (!qsub2a)) {\r
-    PostData(1, fListHist);\r
-    return;\r
-  }\r
-\r
-  AliDebug(1, "Number of tracks");\r
-  \r
-  Int_t nbtracks = fInputEvent->GetNumberOfTracks();\r
-  \r
-  //////////////////////\r
-  // Fill Histos\r
-  //////////////////////\r
-\r
-  fHistEV->Fill(binctt,2.0);\r
-  \r
-  // Fill\r
-  valuensparsea[0] = eventPlaneV0A;\r
-  valuensparsea[1] = eventPlaneV0C;\r
-  valuensparsea[2] = eventPlaneTPC;\r
-  valuensparsea[3] = eventPlaneV0;  \r
-  fEventPlane->Fill(&valuensparsea[0]);\r
-  \r
-  if(!fVZEROEventPlane) {\r
-    valuensparsef[0] = diffsub1sub2a;\r
-    fCosRes->Fill(&valuensparsef[0]);\r
-  }\r
-  else {\r
-    valuensparsefbis[0] = diffsubasubb;\r
-    valuensparsefbis[1] = diffsubbsubc;\r
-    valuensparsefbis[2] = diffsubasubc;\r
-    fCosResabc->Fill(&valuensparsefbis[0]);\r
-  }\r
-    \r
-  \r
-  //////////////////////////\r
-  // Loop over ESD track\r
-  //////////////////////////\r
\r
-  AliDebug(1, "Loop tracks");\r
-\r
-  for(Int_t k = 0; k < nbtracks; k++){\r
-    \r
-    AliVTrack *track = (AliVTrack *) fInputEvent->GetTrack(k);\r
-    if(!track) continue;\r
-\r
-    if(fAODAnalysis) {\r
-      AliAODTrack *aodtrack = dynamic_cast<AliAODTrack *>(track);\r
-      if(!aodtrack){\r
-       AliError("AOD track is not there");\r
-       PostData(1, fListHist);\r
-       return;\r
-      }  \r
-      //printf("Find AOD track on\n");\r
-      if(fUseFlagAOD){\r
-       if(aodtrack->GetFlags() != fFlags) continue;  // Only process AOD tracks where the HFE is set\r
-      }\r
-    }\r
-    \r
-    if(fApplyCut) {\r
-      Bool_t survived = kTRUE;\r
-      for(Int_t icut = AliHFEcuts::kStepRecKineITSTPC; icut <= AliHFEcuts::kStepHFEcutsTRD; icut++){\r
-       if(!fHFECuts->CheckParticleCuts(icut + AliHFEcuts::kNcutStepsMCTrack, (TObject *)track)){\r
-         survived = kFALSE;\r
-         break;\r
-       }\r
-      }\r
-      if(!survived) continue;\r
-    }\r
-    \r
-    // Apply PID\r
-    AliHFEpidObject hfetrack;\r
-    if(!fAODAnalysis) hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);\r
-    else hfetrack.SetAnalysisType(AliHFEpidObject::kAODanalysis);\r
-    hfetrack.SetRecTrack(track);\r
-    hfetrack.SetCentrality((Int_t)binct);\r
-    hfetrack.SetPbPb();\r
-    if(!fPID->IsSelected(&hfetrack,0x0,"recTrackCont",fPIDqa)) {\r
-      continue;\r
-    }\r
-    \r
-    /////////////////////////////////////////////////////////\r
-    // Subtract electron candidate from TPC event plane\r
-    ////////////////////////////////////////////////////////\r
-    Float_t eventplanesubtracted = 0.0;    \r
-\r
-    if(!fVZEROEventPlane) {\r
-      // Subtract the tracks from the event plane\r
-      Double_t qX = standardQ->X() - vEPa->GetQContributionX(track);  //Modify the components: subtract the track you want to look at with your analysis\r
-      Double_t qY = standardQ->Y() - vEPa->GetQContributionY(track);  //Modify the components: subtract the track you want to look at with your analysis\r
-      TVector2 newQVectorfortrack;\r
-      newQVectorfortrack.Set(qX,qY);\r
-      eventplanesubtracted = TVector2::Phi_0_2pi(newQVectorfortrack.Phi())/2; \r
-    }\r
-    else eventplanesubtracted = eventPlanea;\r
-\r
-    ////////////////////////////////////////\r
-    // Fill pt and eta for the THnSparseF\r
-    ///////////////////////////////////////\r
-\r
-    valuensparseg[2] = track->Pt();\r
-    valuensparseh[2] = track->Pt();\r
-    if(track->Charge() > 0.0) {\r
-      valuensparseg[3] = 0.2;\r
-      valuensparseh[3] = 0.2;\r
-    }\r
-    else {\r
-      valuensparseg[3] = -0.2;\r
-      valuensparseh[3] = -0.2;\r
-    }\r
-    valuensparseh[4] = track->Eta();\r
-    valuensparseg[4] = track->Eta();\r
-\r
-    ///////////////////////////////\r
-    // Event plane without track\r
-    /////////////////////////////\r
-    Bool_t fillEventPlane = kTRUE;\r
-    if(!fVZEROEventPlane){\r
-      if((!qsub1a) || (!qsub2a)) fillEventPlane = kFALSE;\r
-      if(fSubEtaGapTPC) {\r
-       if(track->Eta() < (- fEtaGap/2.)) eventplanesubtracted = eventPlanesub1a;\r
-       else if(track->Eta() > (fEtaGap/2.)) eventplanesubtracted = eventPlanesub2a;\r
-       else fillEventPlane = kFALSE;\r
-      }\r
-    }\r
-    \r
-    ///////////////////////\r
-    // Calculate deltaphi\r
-    ///////////////////////\r
-    Double_t phitrack = track->Phi();  \r
-    Double_t deltaphi = TVector2::Phi_0_2pi(phitrack - eventplanesubtracted);\r
-    if(deltaphi > TMath::Pi()) deltaphi = deltaphi - TMath::Pi();\r
-   \r
-    /////////////////////\r
-    // Fill THnSparseF\r
-    /////////////////////\r
-\r
-    valuensparseg[0] = deltaphi;\r
-    if(fillEventPlane) fDeltaPhiMaps->Fill(&valuensparseg[0]);\r
-    \r
-    //\r
-    valuensparseh[0] = TMath::Cos(2*TVector2::Phi_mpi_pi(phitrack-eventplanesubtracted));\r
-    if(fillEventPlane) {\r
-      fCosPhiMaps->Fill(&valuensparseh[0]);\r
-    }\r
-    \r
-  }\r
-\r
-\r
-  AliDebug(1, "Post data");\r
-  \r
-  PostData(1, fListHist);\r
-\r
-\r
\r
-}\r
diff --git a/PWGHF/hfe/AliAnalysisTaskHFEFlowData.h b/PWGHF/hfe/AliAnalysisTaskHFEFlowData.h
deleted file mode 100644 (file)
index 682e373..0000000
+++ /dev/null
@@ -1,116 +0,0 @@
-/**************************************************************************\r
-* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
-*                                                                        *\r
-* Author: The ALICE Off-line Project.                                    *\r
-* Contributors are mentioned in the code where appropriate.              *\r
-*                                                                        *\r
-* Permission to use, copy, modify and distribute this software and its   *\r
-* documentation strictly for non-commercial purposes is hereby granted   *\r
-* without fee, provided that the above copyright notice appears in all   *\r
-* copies and that both the copyright notice and this permission notice   *\r
-* appear in the supporting documentation. The authors make no claims     *\r
-* about the suitability of this software for any purpose. It is          *\r
-* provided "as is" without express or implied warranty.                  *\r
-**************************************************************************/\r
-//\r
-// Flow task class for the ALICE HFE group\r
-//\r
-//\r
-#ifndef ALIANALYSISTASKHFEFLOWDATA_H\r
-#define ALIANALYSISTASKHFEFLOWDATA_H\r
-\r
-\r
-\r
-\r
-#include <AliAnalysisTaskSE.h>\r
-\r
-class TList;\r
-class AliFlowTrackCuts;\r
-class AliFlowCandidateTrack;\r
-class AliHFEcuts;\r
-class AliHFEpid;\r
-class TH1D;\r
-class TH2D;\r
-class TProfile;\r
-class TProfile2D;\r
-class THnSparse;\r
-class AliHFEpidQAmanager;\r
-class AliFlowEvent;\r
-class AliHFEVZEROEventPlane;\r
-\r
-class AliAnalysisTaskHFEFlowData: public AliAnalysisTaskSE {\r
-  \r
-public:\r
-  AliAnalysisTaskHFEFlowData();\r
-  AliAnalysisTaskHFEFlowData(const char *name);\r
-  AliAnalysisTaskHFEFlowData(const AliAnalysisTaskHFEFlowData &ref);\r
-  AliAnalysisTaskHFEFlowData& operator=(const AliAnalysisTaskHFEFlowData &ref);\r
-  virtual void Copy(TObject &o) const;\r
-  virtual ~AliAnalysisTaskHFEFlowData();\r
-  \r
-  virtual void  UserExec(Option_t */*option*/);\r
-  virtual void  UserCreateOutputObjects();\r
-\r
-  void SetAODAnalysis(Bool_t aodAnalysis) { fAODAnalysis = aodAnalysis; };\r
-  void SetUseFlagAOD(Bool_t useFlagAOD) { fUseFlagAOD = useFlagAOD; }\r
-  void SetApplyCut(Bool_t applyCut) { fApplyCut = applyCut; }\r
-  void SetFlags(ULong_t flags)          { fFlags = flags; }\r
-  \r
-  AliHFEpid *GetPID() const { return fPID; }\r
-  AliHFEpidQAmanager *GetPIDQAManager() const { return fPIDqa; }\r
-\r
-  void SetHFECuts(AliHFEcuts * const cuts) { fHFECuts = cuts; };\r
-  void SetSubEtaGapTPC(Bool_t  subEtaGapTPC) { fSubEtaGapTPC = subEtaGapTPC; };\r
-  void SetEtaGap(Double_t  etaGap) { fEtaGap = etaGap; };\r
-  void SetVZEROEventPlane(Bool_t vzeroEventPlane) { fVZEROEventPlane = vzeroEventPlane; };\r
-  void SetVZEROEventPlaneA(Bool_t vzeroEventPlaneA) { fVZEROEventPlaneA = vzeroEventPlaneA; };\r
-  void SetVZEROEventPlaneC(Bool_t vzeroEventPlaneC) { fVZEROEventPlaneC = vzeroEventPlaneC; };\r
-  \r
-  void SetDebugLevel(Int_t debugLevel) { fDebugLevel = debugLevel;};\r
-  \r
-private:\r
-  TList     *fListHist;         //! TH list\r
-  Bool_t    fAODAnalysis;       // AOD analysis\r
-  Bool_t    fUseFlagAOD;        // Use the preselected AOD track\r
-  Bool_t    fApplyCut;       // Apply the analysis cut for AOD tracks\r
-  ULong_t   fFlags;             // reconstruction AOD status flags \r
-  \r
-  Bool_t    fVZEROEventPlane;  // Use Event Planes from VZERO\r
-  Bool_t    fVZEROEventPlaneA; // Use Event Planes from VZERO A\r
-  Bool_t    fVZEROEventPlaneC; // Use Event Planes from VZERO C\r
-\r
-  Bool_t    fSubEtaGapTPC;    // bool to fill with eta gap\r
-  Double_t  fEtaGap;          // Value of the eta gap\r
\r
-  Int_t     fDebugLevel; // Debug Level  \r
-\r
-  // Cuts for HFE\r
-  AliHFEcuts *fHFECuts;           // HFE cuts\r
-  AliHFEpid  *fPID;               // PID cuts \r
-  AliHFEpidQAmanager *fPIDqa;     // QA Manager\r
-  \r
-  // Histos\r
-  TH2D *fHistEV;               //! Number of events\r
-  \r
-  // A Event plane as function of phiepa, phiepb, phiepc, phiepd centrality \r
-  // a V0A, b V0C, c TPC, d V0\r
-  THnSparseF *fEventPlane;     //! Event plane\r
-  \r
-  // Fbis Resolution as function of cosres, cosres, cosres, centrality for three subevents (V0)\r
-  // a V0A, b V0C, c TPC\r
-  THnSparseF *fCosResabc; //! Res\r
-  \r
-  // F Resolution as function of cosres, centrality for two subevents (TPC)\r
-  THnSparseF *fCosRes; //! Res\r
-  \r
-  // G Maps delta phi as function of deltaphi, centrality, pt\r
-  THnSparseF *fDeltaPhiMaps; //! Delta phi\r
-  \r
-  // H Maps cos phi : cos, centrality, pt\r
-  THnSparseF *fCosPhiMaps;         //! Cos\r
-    \r
-  \r
-  ClassDef(AliAnalysisTaskHFEFlowData, 1); // analysisclass\r
-};\r
-\r
-#endif\r
index 4fb1f51..f897849 100644 (file)
@@ -120,6 +120,7 @@ AliHFEcuts::AliHFEcuts():
   fMinClustersTPCPID(0),
   fMinClustersITS(0),
   fMinTrackletsTRD(0),
+  fMaxChi2TRD(-1.),
   fCutITSPixel(0),
   fCheckITSLayerStatus(kTRUE),
   fCutITSDrift(0),
@@ -131,6 +132,7 @@ AliHFEcuts::AliHFEcuts():
   fTOFPIDStep(kFALSE),
   fTOFMISMATCHStep(kFALSE),
   fTPCPIDCLEANUPStep(kFALSE),
+  fITSpatternCut(kFALSE),
   fUseMixedVertex(kTRUE),
   fIsIPSigmacut(kFALSE),
   fIsIPAbs(kTRUE),
@@ -165,6 +167,7 @@ AliHFEcuts::AliHFEcuts(const Char_t *name, const Char_t *title):
   fMinClustersTPCPID(0),
   fMinClustersITS(0),
   fMinTrackletsTRD(0),
+  fMaxChi2TRD(-1.),
   fCutITSPixel(0),
   fCheckITSLayerStatus(kTRUE),
   fCutITSDrift(0),
@@ -176,6 +179,7 @@ AliHFEcuts::AliHFEcuts(const Char_t *name, const Char_t *title):
   fTOFPIDStep(kFALSE),
   fTOFMISMATCHStep(kFALSE),
   fTPCPIDCLEANUPStep(kFALSE),
+  fITSpatternCut(kFALSE),
   fUseMixedVertex(kTRUE),
   fIsIPSigmacut(kFALSE),
   fIsIPAbs(kTRUE),
@@ -209,6 +213,7 @@ AliHFEcuts::AliHFEcuts(const AliHFEcuts &c):
   fMinClustersTPCPID(0),
   fMinClustersITS(0),
   fMinTrackletsTRD(0),
+  fMaxChi2TRD(-1.),
   fCutITSPixel(0),
   fCheckITSLayerStatus(0),
   fCutITSDrift(0),
@@ -220,6 +225,7 @@ AliHFEcuts::AliHFEcuts(const AliHFEcuts &c):
   fTOFPIDStep(kFALSE),
   fTOFMISMATCHStep(kFALSE),
   fTPCPIDCLEANUPStep(kFALSE),
+  fITSpatternCut(c.fITSpatternCut),
   fUseMixedVertex(kTRUE),
   fIsIPSigmacut(kFALSE),
   fIsIPAbs(kTRUE),
@@ -262,6 +268,7 @@ void AliHFEcuts::Copy(TObject &c) const {
   target.fMinClustersTPCPID = fMinClustersTPCPID;
   target.fMinClustersITS = fMinClustersITS;
   target.fMinTrackletsTRD = fMinTrackletsTRD;
+  target.fMaxChi2TRD  = fMaxChi2TRD;
   target.fCutITSPixel = fCutITSPixel;
   target.fCheckITSLayerStatus = fCheckITSLayerStatus;
   target.fCutITSDrift = fCutITSDrift;
@@ -595,6 +602,7 @@ void AliHFEcuts::SetRecKineITSTPCCutList(){
   hfecuts->SetMinNClustersTPCPID(fMinClustersTPCPID);
   hfecuts->SetClusterRatioTPC(fMinClusterRatioTPC, fTPCratioDef);
   if(fFractionOfSharedTPCClusters > 0.0) hfecuts->SetFractionOfTPCSharedClusters(fFractionOfSharedTPCClusters); 
+  if(fITSpatternCut) hfecuts->SetITSpatternCut();
   
   AliCFTrackKineCuts *kineCuts = new AliCFTrackKineCuts((Char_t *)"fCutsKineRec", (Char_t *)"REC Kine Cuts");
   kineCuts->SetPtRange(fPtRange[0], fPtRange[1]);
@@ -728,6 +736,9 @@ void AliHFEcuts::SetHFElectronTRDCuts(){
   AliDebug(2, "Called\n");
   AliHFEextraCuts *hfecuts = new AliHFEextraCuts("fCutsHFElectronGroupTRD","Extra cuts from the HFE group on TRD PID");
   if(fMinTrackletsTRD > 0.) hfecuts->SetMinTrackletsTRD(fMinTrackletsTRD, fTRDtrackletsExact);
+  if(fMaxChi2TRD >= 0)
+    hfecuts->SetMaxChi2TRD(fMaxChi2TRD);
+  
   if(IsQAOn()) hfecuts->SetQAOn(fHistQA);
   hfecuts->SetDebugLevel(fDebugLevel);
   
index e7668a7..197964d 100644 (file)
@@ -142,6 +142,7 @@ class AliHFEcuts : public TNamed{
     void SetMinNClustersTPCPID(UChar_t minClustersTPC) { fMinClustersTPCPID = minClustersTPC; }
     void SetMinNClustersITS(UChar_t minClustersITS) { fMinClustersITS = minClustersITS; }
     void SetMinNTrackletsTRD(UChar_t minNtrackletsTRD, Bool_t exact = kFALSE) { fMinTrackletsTRD = minNtrackletsTRD; fTRDtrackletsExact = exact; }
+    void SetMaxChi2perTrackletTRD(Float_t maxchi2trackletTRD) { fMaxChi2TRD = maxchi2trackletTRD; }
     void SetMaxChi2perClusterITS(Double_t chi2) { fMaxChi2clusterITS = chi2; };
     void SetMaxChi2perClusterTPC(Double_t chi2) { fMaxChi2clusterTPC = chi2; };
     inline void SetMaxImpactParam(Double_t radial, Double_t z);
@@ -162,6 +163,7 @@ class AliHFEcuts : public TNamed{
     void SetTOFPIDStep(Bool_t tofPidStep) {fTOFPIDStep = tofPidStep;};
     void SetTOFMISMATCHStep(Bool_t tofMismatchStep) {fTOFMISMATCHStep = tofMismatchStep;};
     void SetTPCPIDCleanUpStep(Bool_t tpcPIDCleanUpStep) {fTPCPIDCLEANUPStep = tpcPIDCleanUpStep;};
+    void SetITSpatternCut() { fITSpatternCut = kTRUE; }
     void SetUseMixedVertex(Bool_t useMixedVertex) {fUseMixedVertex = useMixedVertex;};    
     void SetFractionOfSharedTPCClusters(Double_t fractionOfSharedTPCClusters) {fFractionOfSharedTPCClusters = fractionOfSharedTPCClusters;};
     void SetMaxImpactParameterRpar(Bool_t maxImpactParameterRpar) { fMaxImpactParameterRpar = maxImpactParameterRpar; };
@@ -196,7 +198,7 @@ class AliHFEcuts : public TNamed{
       kITSPixel = 4,
       kMaxImpactParam = 5,
       kKineMCCuts = 6,
-      kITSDrift = 7,
+      kITSDrift = 7
     } Require_t;
     void SetParticleGenCutList();
     void SetAcceptanceCutList();
@@ -227,6 +229,7 @@ class AliHFEcuts : public TNamed{
     UChar_t fMinClustersTPCPID;          // Min.Number of TPC clusters
     UChar_t fMinClustersITS;       // Min.Number of TPC clusters
     UChar_t fMinTrackletsTRD;      // Min. Number of TRD tracklets
+    Float_t fMaxChi2TRD;                // Max. Chi2 per TRD tracklet
     UChar_t fCutITSPixel;              // Cut on ITS pixel
     Bool_t  fCheckITSLayerStatus;       // Check ITS layer status
     UChar_t fCutITSDrift;              // Cut on ITS drift
@@ -239,6 +242,7 @@ class AliHFEcuts : public TNamed{
     Bool_t   fTOFPIDStep;               // TOF matching step efficiency
     Bool_t   fTOFMISMATCHStep;        // TOF mismatch step
     Bool_t   fTPCPIDCLEANUPStep;      // TPC PIC cleanup step
+    Bool_t   fITSpatternCut;          // Cut on ITS pattern
     Bool_t   fUseMixedVertex;         // Use primary vertex from track only as before
     Float_t  fIPCutParams[4];         // Parameters of impact parameter cut parametrization
     Bool_t   fIsIPSigmacut;           // if IP cut or IP sigma cut 
diff --git a/PWGHF/hfe/AliHFEdca.cxx b/PWGHF/hfe/AliHFEdca.cxx
deleted file mode 100644 (file)
index 1f27dec..0000000
+++ /dev/null
@@ -1,1671 +0,0 @@
-/*************************************************************************
-* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
-*                                                                        *
-* Author: The ALICE Off-line Project.                                    *
-* Contributors are mentioned in the code where appropriate.              *
-*                                                                        *
-* Permission to use, copy, modify and distribute this software and its   *
-* documentation strictly for non-commercial purposes is hereby granted   *
-* without fee, provided that the above copyright notice appears in all   *
-* copies and that both the copyright notice and this permission notice   *
-* appear in the supporting documentation. The authors make no claims     *
-* about the suitability of this software for any purpose. It is          *
-* provided "as is" without express or implied warranty.                  *
-**************************************************************************/
-//
-// Class for impact parameter (DCA) of charged particles
-// Study resolution and pull: prepare for beauty study
-//
-// Authors:
-//   Hongyan Yang <hongyan@physi.uni-heidelberg.de>
-//   Carlo Bombonati <carlo.bombonati@cern.ch>
-//
-
-#include "TMath.h"
-#include "TH1F.h"
-#include "TList.h"
-#include <TParticle.h>
-#include "AliMCParticle.h"
-#include "AliESDtrack.h"
-#include "AliESDEvent.h"
-#include "AliMCEvent.h"
-#include "AliMCVertex.h"
-
-#include "AliKFParticle.h"
-#include "AliKFVertex.h"
-
-#include "AliESDVertex.h"
-
-#include "AliPID.h"
-
-#include "AliHFEdca.h"
-
-
-ClassImp(AliHFEdca)
-
-//________________________________________________________________________
-const Char_t* AliHFEdca::fgkParticles[12] = {
- // particles name
- "electron", "muonMinus","pionMinus", "kaonMinus", "protonMinus", 
- "positron", "muonPlus", "pionPlus", "kaonPlus", "protonPlus",
- "allNegative", "allPositive"
-};
-
-const Int_t AliHFEdca::fgkPdgParticle[10] = { 
-//   11, 13, -211, -233, -2122,  
-//   -11, -13, 211, 233, 2122};
- kPDGelectron, kPDGmuon, -kPDGpion, -kPDGkaon, -kPDGproton, 
- -kPDGelectron, -kPDGmuon, kPDGpion, kPDGkaon, kPDGproton};
-
-//________________________________________________________________________
-const Int_t AliHFEdca::fgkColorPart[12] = { 
- // colors assigned to particles
- kRed, kBlue, kGreen+2, kYellow+2, kMagenta, 
- kRed+2, kBlue+2, kGreen+4, kYellow+4, kMagenta+2,
- kBlack, kGray+1
-};
-
-//________________________________________________________________________
-const Float_t AliHFEdca::fgkPtIntv[51] = {
- // define pT bins
- 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.50, 0.55, 
- 0.60, 0.70, 0.80, 0.90, 1.00, 1.10, 1.20, 1.30, 1.40, 1.50, 
- 1.70, 1.90, 2.10, 2.30, 2.50, 2.70, 2.90, 3.10, 3.30, 3.50, 
- 3.80, 4.10, 4.40, 4.70, 5.00, 5.30, 5.60, 5.90, 6.20, 6.50, 
- 7.00, 7.50, 8.00, 9.00, 10.0, 11.0, 12.0, 13.0, 15.0, 18.0, 
- 20.00};
-
-//________________________________________________________________________
-const Char_t *AliHFEdca::fgkDcaVar[2] = {
- "DcaXY",  "DcaZ"};
-
-//________________________________________________________________________
-const Char_t *AliHFEdca::fgkDcaVarTitle[2] ={
- ";dca_{xy} [#mum];counts", ";dca_{z} [#mum];counts"};
-
-//________________________________________________________________________
-const Char_t *AliHFEdca::fgkVertexVar[3] = {
- "VertexX", "VertexY", "VertexZ"};
-
-//________________________________________________________________________
-const Char_t *AliHFEdca::fgkVertexVarTitle[3] ={
- ";vertex_{x} [#mum];counts", ";vertex_{y} [#mum];counts", ";vertex_{z} [#mum];counts"};
-
-//________________________________________________________________________
-const Char_t *AliHFEdca::fgkResDcaVar[2] = {
- "deltaDcaXY",  "deltaDcaZ"};
-
-//________________________________________________________________________
-const Char_t *AliHFEdca::fgkResDcaVarTitle[2] ={
- ";residual #Delta(d_{xy}) [#mum];counts", ";residual #Delta(d_{z}) [#mum];counts"};
-
-//________________________________________________________________________
-const Char_t *AliHFEdca::fgkPullDcaVar[2] = {
- "pullDcaXY", "pullDcaZ"
-};
-
-//________________________________________________________________________
-const Char_t *AliHFEdca::fgkPullDcaVarTitle[2] = {
- ";residual dca_{xy}/(error dca_{xy});counts", 
- ";residual dca_{z}/(error dca_{z});counts"
-};
-
-//________________________________________________________________________
-const Char_t *AliHFEdca::fgkPullDataDcaVarTitle[2] = {
- ";dca_{xy}^{data}/error dca_{xy};counts", 
- ";dca_{z}^{data}/error dca_{z};counts"
-};
-
-//________________________________________________________________________
-AliHFEdca::AliHFEdca():
-  TObject(),
-  fStat(NULL)
-{
- // default constructor
-
- for(Int_t j=0; j<kNParticles; j++){
-   fHistMcPid[j] = new TH1F();
-   fHistEsdPid[j] = new TH1F();
-   fHistDataEsdPid[j] = new TH1F();
- }
-
- for(Int_t i=0; i<3; i++){
-   fHistMCvertex[i] = new TH1F();
-   fHistESDvertex[i] = new TH1F();
-   fHistDatavertex[i] = new TH1F();   
- }
- for(Int_t iEle=0; iEle<2; iEle++){
-   fHistDataHfePid[iEle] = new TH1F();
- }
-
-}
-
-//________________________________________________________________________
-AliHFEdca::AliHFEdca(const AliHFEdca &ref):
- TObject(ref),
- fStat(ref.fStat)
-{
- // copy constructor
-
- for(Int_t j=0; j<kNParticles; j++){
-   fHistMcPid[j] = ref.fHistMcPid[j];
-   fHistEsdPid[j] = ref.fHistEsdPid[j];
-   fHistDataEsdPid[j] = ref.fHistDataEsdPid[j];
- }
-
- for(Int_t i=0; i<3; i++){
-   fHistMCvertex[i] = ref.fHistMCvertex[i];
-   fHistESDvertex[i] = ref.fHistESDvertex[i];
-   fHistDatavertex[i] = ref.fHistDatavertex[i];
- }
- for(Int_t iEle=0; iEle<2; iEle++){
-   fHistDataHfePid[iEle] = ref.fHistDataHfePid[iEle];
- }
-
-}
-//_______________________________________________________________________________________________
-AliHFEdca&AliHFEdca::operator=(const AliHFEdca &ref)
-{
- //
- // Assignment operator
- //
-
- if(this == &ref) return *this;
- TObject::operator=(ref);
- return *this;
-
-}
-
-//________________________________________________________________________
-AliHFEdca::~AliHFEdca()
-{
- // default destructor
-
- for(Int_t j=0; j<kNParticles; j++){
-   for(Int_t i=0; i<kNPtBins; i++){
-     if(fHistDcaXYRes[j][i]) delete fHistDcaXYRes[j][i];
-     if(fHistDcaZRes[j][i]) delete fHistDcaZRes[j][i];
-
-     if(fHistDcaXYPull[j][i]) delete fHistDcaXYPull[j][i];
-     if(fHistDcaZPull[j][i]) delete fHistDcaZPull[j][i];
-
-     if(fHistDcaXY[j][i]) delete fHistDcaXY[j][i];
-     if(fHistDcaZ[j][i]) delete fHistDcaZ[j][i];
-
-     if(j<(kNParticles-2)){
-       if(fHistEPDcaXYRes[j][i]) delete fHistEPDcaXYRes[j][i];
-       if(fHistEPDcaZRes[j][i]) delete fHistEPDcaZRes[j][i];
-       
-       if(fHistEPDcaXYPull[j][i]) delete fHistEPDcaXYPull[j][i];
-       if(fHistEPDcaZPull[j][i]) delete fHistEPDcaZPull[j][i];
-       
-       if(fHistEPDcaXY[j][i]) delete fHistEPDcaXY[j][i];
-       if(fHistEPDcaZ[j][i]) delete fHistEPDcaZ[j][i];
-     }
-
-     if(fHistKFDcaXY[j][i]) delete fHistKFDcaXY[j][i];
-     if(fHistKFDcaZ[j][i]) delete fHistKFDcaZ[j][i];
-
-     if(fHistDataDcaXY[j][i]) delete fHistDataDcaXY[j][i];
-     if(fHistDataDcaZ[j][i]) delete fHistDataDcaZ[j][i];
-     if(fHistDataWoDcaXY[j][i]) delete fHistDataWoDcaXY[j][i];
-     if(fHistDataWoDcaZ[j][i]) delete fHistDataWoDcaZ[j][i];
-
-     if(fHistDataDcaXYPull[j][i]) delete fHistDataDcaXYPull[j][i];
-     if(fHistDataDcaZPull[j][i]) delete fHistDataDcaZPull[j][i];
-     if(fHistDataWoDcaXYPull[j][i]) delete fHistDataWoDcaXYPull[j][i];
-     if(fHistDataWoDcaZPull[j][i]) delete fHistDataWoDcaZPull[j][i];
-   }
-
-   if(fHistMcPid[j]) delete fHistMcPid[j];
-   if(fHistEsdPid[j]) delete fHistEsdPid[j];
-   if(fHistDataEsdPid[j]) delete fHistDataEsdPid[j];
- }
-
- for(Int_t i=0; i<3; i++){
-   if(fHistMCvertex[i]) delete fHistMCvertex[i];
-   if(fHistESDvertex[i]) delete fHistESDvertex[i];
-   if(fHistDatavertex[i]) delete fHistDatavertex[i];    
- }
-
- // for the HFEpid
- for(Int_t iEle=0; iEle<2; iEle++){
-   for(Int_t iPt=0; iPt<kNPtBins; iPt++){
-     if(fHistHPDcaXYRes[iEle][iPt]) delete fHistHPDcaXYRes[iEle][iPt]; 
-     if(fHistHPDcaZRes[iEle][iPt]) delete fHistHPDcaZRes[iEle][iPt];   
-     if(fHistHPDcaXYPull[iEle][iPt]) delete fHistHPDcaXYPull[iEle][iPt]; 
-     if(fHistHPDcaZPull[iEle][iPt]) delete fHistHPDcaZPull[iEle][iPt];  
-     if(fHistHPDcaXY[iEle][iPt]) delete fHistHPDcaXY[iEle][iPt];     
-     if(fHistHPDcaZ[iEle][iPt]) delete fHistHPDcaZ[iEle][iPt];      
-     
-     
-     // Data
-     if(fHistHPDataDcaXY[iEle][iPt]) delete fHistHPDataDcaXY[iEle][iPt];   
-     if(fHistHPDataDcaZ[iEle][iPt]) delete fHistHPDataDcaZ[iEle][iPt];   
-     if(fHistHPDataDcaXYPull[iEle][iPt]) delete fHistHPDataDcaXYPull[iEle][iPt];   
-     if(fHistHPDataDcaZPull[iEle][iPt]) delete fHistHPDataDcaZPull[iEle][iPt];    
-
-   }
-   for(Int_t i=0; i<2; i++)
-     if(fHistHfePid[iEle][i]) delete fHistHfePid[iEle][i];
-
-   if(fHistDataHfePid[iEle]) delete fHistDataHfePid[iEle];
-
- }
-
- if(fStat) delete fStat;
-
- //Printf("analysis done\n");
-
-}
-
-//________________________________________________________________________
-void AliHFEdca::InitAnalysis()const{
-
- //Printf("initialize analysis\n");
-
-}
-
-
-//________________________________________________________________________
-void AliHFEdca::PostAnalysis() const
-{
- // do fit
- // moved to dcaPostAnalysis.C
-
-}
-
-
-//________________________________________________________________________
-void AliHFEdca::CreateHistogramsResidual(TList *residualList){
- // define histogram
- // 1. residual
-
- // for residuals
-  // fHistDcaXYRes[kNParticles][kNPtBins]=0x0;
-  // fHistDcaZRes[kNParticles][kNPtBins]=0x0;
-  // fHistEPDcaXYRes[kNParticles-2][kNPtBins]=0x0;
- // fHistEPDcaZRes[kNParticles-2][kNPtBins]=0x0;
-
- const Int_t nBins = 1000;
- const Float_t maxXYBin = 1000.;
- const Float_t maxZBin = 1000.;
-
-
- for(Int_t k=0; k<kNDcaVar; k++){
-   TString histTitle((const char*)fgkResDcaVarTitle[k]);
-
-   for(Int_t j=0; j<kNParticles; j++){
-     for(Int_t i=0; i<kNPtBins; i++){
-       
-       TString histName((const char*)fgkParticles[j]);
-       histName += Form("_MCpid_%s_pT-%.2f-%.2f", (const char*)fgkResDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-       TString histEPName((const char*)fgkParticles[j]);
-       histEPName += Form("_ESDpid_%s_pT-%.2f-%.2f", (const char*)fgkResDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-       
-       if(k==0){
-         fHistDcaXYRes[j][i] = new TH1F((const char*)histName, (const char*)histTitle, nBins, -maxXYBin, maxXYBin);
-         fHistDcaXYRes[j][i]->SetLineColor((int)fgkColorPart[j]);
-         if(j<(kNParticles-2)){
-           fHistEPDcaXYRes[j][i] = new TH1F((const char*)histEPName, (const char*)histTitle, nBins, -maxXYBin, maxXYBin);
-           fHistEPDcaXYRes[j][i]->SetLineColor((int)fgkColorPart[j]);}
-       }           
-       if(k==1){
-         fHistDcaZRes[j][i] = new TH1F((const char*)histName, (const char*)histTitle, nBins, -maxZBin, maxZBin);
-         fHistDcaZRes[j][i]->SetLineColor((int)fgkColorPart[j]);
-         if(j<(kNParticles-2)){
-           fHistEPDcaZRes[j][i] = new TH1F((const char*)histEPName, (const char*)histTitle, nBins, -maxZBin, maxZBin);
-           fHistEPDcaZRes[j][i]->SetLineColor((int)fgkColorPart[j]); }
-       }   
-     } // 50 pt bins
-   } //12 nparticles
- } // 2 dca var
-
- //  TList *fResidualList = 0;
- residualList->SetOwner();
- residualList->SetName("residual");
- for(Int_t iPart=0; iPart<kNParticles; iPart++){
-   for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-     residualList->Add(fHistDcaXYRes[iPart][iPtBin]);  
-     residualList->Add(fHistDcaZRes[iPart][iPtBin]);  
-     if(iPart<(kNParticles-2)){
-       residualList->Add(fHistEPDcaXYRes[iPart][iPtBin]);  
-       residualList->Add(fHistEPDcaZRes[iPart][iPtBin]);  
-     }
-   } // loop over pt bins
- }  // loop over particles (pos, neg)
-
-
-
-}
-
-
-//________________________________________________________________________
-void AliHFEdca::CreateHistogramsPull(TList *pullList){
- // define histogram
- // 2. pull
-
- const Int_t nBins = 1000;
- const Float_t maxXYBin = 20.;
- const Float_t maxZBin = 20.;
-
-
- // for pull -----------------------------------------------------------------------
- // fHistDcaXYPull[kNParticles][kNPtBins]=0x0;
- // fHistDcaZPull[kNParticles][kNPtBins]=0x0;
- // fHistEPDcaXYPull[kNParticles-2][kNPtBins]=0x0;
- // fHistEPDcaZPull[kNParticles-2][kNPtBins]=0x0;
-
-
- for(Int_t k=0; k<kNDcaVar; k++){
-   TString histTitle((const char*)fgkPullDcaVarTitle[k]);
-
-   for(Int_t j=0; j<kNParticles; j++){
-     for(Int_t i=0; i<kNPtBins; i++){
-       
-       TString histName((const char*)fgkParticles[j]); 
-       histName += Form("_MCpid_%s_pT-%.2f-%.2f", (const char*)fgkPullDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-       TString histEPName((const char*)fgkParticles[j]);       
-       histEPName += Form("_ESDpid_%s_pT-%.2f-%.2f", (const char*)fgkPullDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-       
-       if(k==0){
-         fHistDcaXYPull[j][i] = new TH1F((const char*)histName, (const char*)histTitle, nBins, 1-maxXYBin, 1+maxXYBin);
-         fHistDcaXYPull[j][i]->SetLineColor((int)fgkColorPart[j]);
-         if(j<(kNParticles-2))    {
-           fHistEPDcaXYPull[j][i] = new TH1F((const char*)histEPName, (const char*)histTitle, nBins, 1-maxXYBin, 1+maxXYBin);
-           fHistEPDcaXYPull[j][i]->SetLineColor((int)fgkColorPart[j]);}
-       }           
-       if(k==1){
-         fHistDcaZPull[j][i] = new TH1F((const char*)histName, (const char*)histTitle, nBins, 1-maxZBin, 1+maxZBin);
-         fHistDcaZPull[j][i]->SetLineColor((int)fgkColorPart[j]);
-         if(j<(kNParticles-2))    {
-           fHistEPDcaZPull[j][i] = new TH1F((const char*)histEPName, (const char*)histTitle, nBins, 1-maxZBin, 1+maxZBin);
-           fHistEPDcaZPull[j][i]->SetLineColor((int)fgkColorPart[j]);}
-       }   
-     } // 50 pt bins
-   } //6 nparticles
- } // 2 dca var
-
- //  TList *fPullList = 0;
- pullList->SetOwner();
- pullList->SetName("pull");
- for(Int_t iPart=0; iPart<kNParticles; iPart++){
-   for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-     pullList->Add(fHistDcaXYPull[iPart][iPtBin]);  
-     pullList->Add(fHistDcaZPull[iPart][iPtBin]);  
-     if(iPart<(kNParticles-2)){
-       pullList->Add(fHistDcaXYPull[iPart][iPtBin]);  
-       pullList->Add(fHistDcaZPull[iPart][iPtBin]); }
-   } // loop over pt bins
- }  // loop over particles (pos, neg)
-
-}
-
-
-//________________________________________________________________________
-void AliHFEdca::CreateHistogramsDca(TList *dcaList){
- // 
- // define histograms: MC dca
- //
-
- // statistics
- fStat = 0x0;
- fStat = new TH1I("fStatistics", "allStatistics;ID;counts", 7, -3.5, 3.5);
- fStat->SetMarkerStyle(20); 
- fStat->SetMarkerColor(3); 
- fStat->SetMarkerSize(1); 
-
- // for dca
- // fHistDcaXY[kNParticles][kNPtBins]=0x0;
- // fHistDcaZ[kNParticles][kNPtBins]=0x0;
- // fHistEPDcaXY[kNParticles-2][kNPtBins]=0x0;
- // fHistEPDcaZ[kNParticles-2][kNPtBins]=0x0;
-
- const Int_t nBins = 1000;
- const Float_t maxXYBin = 1000.;
- const Float_t maxZBin = 1000.;
-
-
- for(Int_t k=0; k<kNDcaVar; k++){
-   TString histTitle((const char*)fgkDcaVarTitle[k]);
-
-   for(Int_t j=0; j<kNParticles; j++){
-     for(Int_t i=0; i<kNPtBins; i++){
-       
-       TString histName((const char*)fgkParticles[j]); 
-       histName += Form("_MCpid_%s_pT-%.2f-%.2f", (const char*)fgkDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-       
-       TString histNameEP((const char*)fgkParticles[j]);       
-       histNameEP += Form("_ESDpid_%s_pT-%.2f-%.2f", (const char*)fgkDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-
-       if(k==0){
-         fHistDcaXY[j][i] = new TH1F((const char*)histName, (const char*)histTitle, nBins, -maxXYBin, maxXYBin);
-         fHistDcaXY[j][i]->SetLineColor((int)fgkColorPart[j]);
-         
-         if(j<(kNParticles-2)){
-           fHistEPDcaXY[j][i] = new TH1F((const char*)histNameEP, (const char*)histTitle, nBins, -maxXYBin, maxXYBin);
-           fHistEPDcaXY[j][i]->SetLineColor((int)fgkColorPart[j]);}
-       }           
-       if(k==1){
-         fHistDcaZ[j][i] = new TH1F((const char*)histName, (const char*)histTitle, nBins, -maxZBin, maxZBin);
-         fHistDcaZ[j][i]->SetLineColor((int)fgkColorPart[j]);
-         if(j<(kNParticles-2)){
-           fHistEPDcaZ[j][i] = new TH1F((const char*)histNameEP, (const char*)histTitle, nBins, -maxZBin, maxZBin);
-           fHistEPDcaZ[j][i]->SetLineColor((int)fgkColorPart[j]);}
-       }   
-     } // 50 pt bins
-   } //12 nparticles
- } // 2 dca var
-
-   //  TList *fDcaList = 0;
- dcaList->SetOwner();
- dcaList->SetName("mcDcaDistr");
- for(Int_t iPart=0; iPart<kNParticles; iPart++){
-   for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-     dcaList->Add(fHistDcaXY[iPart][iPtBin]);  
-     dcaList->Add(fHistDcaZ[iPart][iPtBin]);  
-     if(iPart<(kNParticles-2)) {
-       dcaList->Add(fHistEPDcaXY[iPart][iPtBin]);  
-       dcaList->Add(fHistEPDcaZ[iPart][iPtBin]); }
-   } // loop over pt bins
- }  // loop over particles (pos, neg)
-
- dcaList->Add(fStat);
-
-}
-
-//________________________________________________________________________
-void AliHFEdca::CreateHistogramsKfDca(TList *kfDcaList){
- // 
- // define histograms: MC dca
- //
-
- // statistics
- fStat = 0x0;
- fStat = new TH1I("fStatistics", "allStatistics;ID;counts", 7, -3.5, 3.5);
- fStat->SetMarkerStyle(20); 
- fStat->SetMarkerColor(3); 
- fStat->SetMarkerSize(1); 
-
- // for kf dca
- // fHistKFDcaXY[kNParticles][kNPtBins]=0x0;
- // fHistKFDcaZ[kNParticles][kNPtBins]=0x0;
-
- const Int_t nBins = 1000;
- const Float_t maxXYBin = 1000.;
- const Float_t maxZBin = 1000.;
-
-
- for(Int_t k=0; k<kNDcaVar; k++){
-   TString histTitle((const char*)fgkDcaVarTitle[k]);
-
-   for(Int_t j=0; j<kNParticles; j++){
-     for(Int_t i=0; i<kNPtBins; i++){
-       TString histNameKF((const char*)fgkParticles[j]);       
-       histNameKF += Form("_MCpid_KF%s_pT-%.2f-%.2f", (const char*)fgkDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-       
-       if(k==0){
-         fHistKFDcaXY[j][i] = new TH1F((const char*)histNameKF, (const char*)histTitle, nBins, -maxXYBin, maxXYBin);
-         fHistKFDcaXY[j][i]->SetLineColor((int)fgkColorPart[j]);
-       }           
-       if(k==1){
-         fHistKFDcaZ[j][i] = new TH1F((const char*)histNameKF, (const char*)histTitle, nBins, -maxZBin, maxZBin);
-         fHistKFDcaZ[j][i]->SetLineColor((int)fgkColorPart[j]);
-       }   
-     } // 50 pt bins
-   } //12 nparticles
- } // 2 dca var
-
- kfDcaList->SetOwner();
- kfDcaList->SetName("mcKfDcaDistr");
- for(Int_t iPart=0; iPart<kNParticles; iPart++){
-   for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-     kfDcaList->Add(fHistKFDcaXY[iPart][iPtBin]);  
-     kfDcaList->Add(fHistKFDcaZ[iPart][iPtBin]);  
-   } // loop over pt bins
- }  // loop over particles (pos, neg)
-
- kfDcaList->Add(fStat);
-
-}
-
-
-//________________________________________________________________________
-void AliHFEdca::CreateHistogramsDataDca(TList *dataDcaList){
- //
- // define histograms: real Data
- //
-
- // for dca
-//  fHistDataDcaXY[kNParticles][kNPtBins]=0x0;
-//  fHistDataDcaZ[kNParticles][kNPtBins]=0x0;
-//  fHistDataWoDcaXY[kNParticles][kNPtBins]=0x0;
-//  fHistDataWoDcaZ[kNParticles][kNPtBins]=0x0;
-
- const Int_t nBins = 1000;
- const Float_t maxXYBin = 1000.;
- const Float_t maxZBin = 1000.;
-
- for(Int_t k=0; k<kNDcaVar; k++){
-   TString histTitle((const char*)fgkDcaVarTitle[k]);    
-   for(Int_t j=0; j<kNParticles; j++){
-     for(Int_t i=0; i<kNPtBins; i++){
-       
-       TString histName((const char*)fgkParticles[j]); 
-       histName += Form("_%s_Data_pT-%.2f-%.2f", (const char*)fgkDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-
-       TString histNameWo((const char*)fgkParticles[j]);       
-       histNameWo += Form("_%s_Data_wo_pT-%.2f-%.2f", (const char*)fgkDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-       
-       if(k==0){
-         fHistDataDcaXY[j][i] = new TH1F((const char*)histName, (const char*)histTitle, nBins, -maxXYBin, maxXYBin);
-         fHistDataDcaXY[j][i]->SetLineColor((int)fgkColorPart[j]);
-
-         fHistDataWoDcaXY[j][i] = new TH1F((const char*)histNameWo, (const char*)histTitle, nBins, -maxXYBin, maxXYBin);
-         fHistDataWoDcaXY[j][i]->SetLineColor((int)fgkColorPart[j]);
-       }           
-       if(k==1){
-         fHistDataDcaZ[j][i] = new TH1F((const char*)histName, (const char*)histTitle, nBins, -maxZBin, maxZBin);
-         fHistDataDcaZ[j][i]->SetLineColor((int)fgkColorPart[j]);
-
-         fHistDataWoDcaZ[j][i] = new TH1F((const char*)histNameWo, (const char*)histTitle, nBins, -maxZBin, maxZBin);
-         fHistDataWoDcaZ[j][i]->SetLineColor((int)fgkColorPart[j]);
-       }   
-     } // 50 pt bins
-   } //12 nparticles
- } // 2 dca var
-
-   //  TList *fDcaList = 0;
- dataDcaList->SetOwner();
- dataDcaList->SetName("dataDcaDistr");
- for(Int_t iPart=0; iPart<kNParticles; iPart++){
-   for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-     dataDcaList->Add(fHistDataDcaXY[iPart][iPtBin]);  
-     dataDcaList->Add(fHistDataDcaZ[iPart][iPtBin]);  
-
-     dataDcaList->Add(fHistDataWoDcaXY[iPart][iPtBin]);  
-     dataDcaList->Add(fHistDataWoDcaZ[iPart][iPtBin]);  
-   } // loop over pt bins
- }  // loop over particles (pos, neg)
-
-
-}
-
-
-//________________________________________________________________________
-void AliHFEdca::CreateHistogramsDataPull(TList *dataPullList){
- // define histogram
- // 2. pull
-
- const Int_t nBins = 1000;
- const Float_t maxXYBin = 20.;
- const Float_t maxZBin = 20.;
-
- // for pull -----------------------------------------------------------------------
-//  fHistDataDcaXYPull[kNParticles][kNPtBins]=0x0;
-//  fHistDataDcaZPull[kNParticles][kNPtBins]=0x0;
-
-//  fHistDataWoDcaXYPull[kNParticles][kNPtBins]=0x0;
-//  fHistDataWoDcaZPull[kNParticles][kNPtBins]=0x0;
-
-
- for(Int_t k=0; k<kNDcaVar; k++){
-   TString histTitle((const char*)fgkPullDataDcaVarTitle[k]);
-
-   for(Int_t j=0; j<kNParticles; j++){
-     for(Int_t i=0; i<kNPtBins; i++){
-       
-       TString histName((const char*)fgkParticles[j]); 
-       histName += Form("_%s_Data_pT-%.2f-%.2f", (const char*)fgkPullDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-
-       TString histNameWo((const char*)fgkParticles[j]);       
-       histNameWo += Form("_%s_Data_wo_pT-%.2f-%.2f", (const char*)fgkPullDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-       
-       if(k==0){
-         fHistDataDcaXYPull[j][i] = new TH1F((const char*)histName, (const char*)histTitle, nBins, 1-maxXYBin, 1+maxXYBin);
-         fHistDataDcaXYPull[j][i]->SetLineColor((int)fgkColorPart[j]);
-
-         fHistDataWoDcaXYPull[j][i] = new TH1F((const char*)histNameWo, (const char*)histTitle, nBins, 1-maxXYBin, 1+maxXYBin);
-         fHistDataWoDcaXYPull[j][i]->SetLineColor((int)fgkColorPart[j]);
-       }           
-       if(k==1){
-         fHistDataDcaZPull[j][i] = new TH1F((const char*)histName, (const char*)histTitle, nBins, 1-maxZBin, 1+maxZBin);
-         fHistDataDcaZPull[j][i]->SetLineColor((int)fgkColorPart[j]);
-
-         fHistDataWoDcaZPull[j][i] = new TH1F((const char*)histNameWo, (const char*)histTitle, nBins, 1-maxZBin, 1+maxZBin);
-         fHistDataWoDcaZPull[j][i]->SetLineColor((int)fgkColorPart[j]);
-       }   
-     } // 50 pt bins
-   } //6 nparticles
- } // 2 dca var
-
- //  TList *fDataPullList = 0;
- dataPullList->SetOwner();
- dataPullList->SetName("dataPull");
- for(Int_t iPart=0; iPart<kNParticles; iPart++){
-   for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-     dataPullList->Add(fHistDataDcaXYPull[iPart][iPtBin]);  
-     dataPullList->Add(fHistDataDcaZPull[iPart][iPtBin]);  
-
-     dataPullList->Add(fHistDataWoDcaXYPull[iPart][iPtBin]);  
-     dataPullList->Add(fHistDataWoDcaZPull[iPart][iPtBin]);  
-   } // loop over pt bins
- }  // loop over particles (pos, neg)
-
-}
-
-//________________________________________________________________________
-void AliHFEdca::CreateHistogramsVertex(TList *vertexList){
- //
- // define histograms: vertex
- //
- // for  vertex
-
-//  fHistMCvertex[kNVertexVar]=0x0;
-//  fHistESDvertex[kNVertexVar]=0x0;
-
- const Int_t nBins = 1000;
- const Float_t minXBin = -0.2e4;
- const Float_t maxXBin = 0.2e4;
- const Float_t minYBin = -0.5e4;
- const Float_t maxYBin = 0.5e4;
- const Float_t minZBin = -1.5e5;
- const Float_t maxZBin = 1.5e5;
-
- const Float_t minBin[kNVertexVar] = {minXBin, minYBin, minZBin};
- const Float_t maxBin[kNVertexVar] = {maxXBin, maxYBin, maxZBin};
-
- for(Int_t k=0; k<kNVertexVar; k++){
-   TString histTitle((const char*)fgkVertexVarTitle[k]);    
-   TString histNameMC((const char*)fgkVertexVar[k]);
-   histNameMC += Form("_MC");
-   TString histNameESD((const char*)fgkVertexVar[k]);
-   histNameESD += Form("_ESD");
-
-   fHistMCvertex[k] = new TH1F((const char*)histNameMC, (const char*)histTitle, nBins, minBin[k], maxBin[k]);
-   fHistMCvertex[k]->SetLineColor(k+2);
-
-   fHistESDvertex[k] = new TH1F((const char*)histNameESD, (const char*)histTitle, nBins, minBin[k], maxBin[k]);
-   fHistESDvertex[k]->SetLineColor(k+2);
- } // 3 vertex var
-
- vertexList->SetOwner();
- vertexList->SetName("vertexDistr");
-
- for(Int_t k=0; k<kNVertexVar; k++){
-   vertexList->Add(fHistMCvertex[k]);  
-   vertexList->Add(fHistESDvertex[k]);  
- }
-
-}
-
-
-
-//________________________________________________________________________
-void AliHFEdca::CreateHistogramsDataVertex(TList *dataVertexList){
- //
- // define histograms: vertex
- //
- // for data vertex
-
-//  fHistDatavertex[kNVertexVar]=0x0;
-
- const Int_t nBins = 1000;
- const Float_t minXBin = -0.2e4;
- const Float_t maxXBin = 0.2e4;
- const Float_t minYBin = -0.5e4;
- const Float_t maxYBin = 0.5e4;
- const Float_t minZBin = -1.5e5;
- const Float_t maxZBin = 1.5e5;
-
- const Float_t minBin[kNVertexVar] = {minXBin, minYBin, minZBin};
- const Float_t maxBin[kNVertexVar] = {maxXBin, maxYBin, maxZBin};
-
- for(Int_t k=0; k<kNVertexVar; k++){
-   TString histTitle((const char*)fgkVertexVarTitle[k]);    
-   TString histNameDataESD((const char*)fgkVertexVar[k]);
-   histNameDataESD += Form("_data");
-
-   fHistDatavertex[k] = new TH1F((const char*)histNameDataESD, (const char*)histTitle, nBins, minBin[k], maxBin[k]);
-   fHistDatavertex[k]->SetLineColor(k+2);
- } // 3 vertex var
-
-   //  TList *fVDaraVertexList = 0;
- dataVertexList->SetOwner();
- dataVertexList->SetName("dataVertexDistr");
-
- for(Int_t k=0; k<kNVertexVar; k++){
-   dataVertexList->Add(fHistDatavertex[k]);  
- }
-
-}
-
-//_______________________________________________________________________________________________
-void AliHFEdca::CreateHistogramsPid(TList *mcPidList){
- //
- // define histograms which fills combined PID
- //
-
- const Char_t *mcOResd[2]={"mcPt", "esdPt"};
-
- for(Int_t iPart=0; iPart<kNParticles; iPart++){
-   TString histTitleMc((const char*)fgkParticles[iPart]);
-   TString histTitleEsd((const char*)fgkParticles[iPart]);
-   histTitleMc += Form("_McPid_%s;p_{T} [GeV/c];counts", mcOResd[0]);
-   histTitleEsd += Form("_EsdPid_%s;p_{T} [GeV/c];counts", mcOResd[1]);
-
-   TString histNameMc((const char*)fgkParticles[iPart]);
-   TString histNameEsd((const char*)fgkParticles[iPart]);
-   histNameMc+=Form("_McPid_%s", mcOResd[0]);     
-   histNameEsd+=Form("_EsdPid_%s", mcOResd[1]);     
-
-   fHistMcPid[iPart] = new TH1F(histNameMc, histTitleMc, kNPtBins, fgkPtIntv);
-   fHistEsdPid[iPart] = new TH1F(histNameEsd, histTitleEsd, kNPtBins, fgkPtIntv);
- }
-
-
- mcPidList->SetOwner();
- mcPidList->SetName("combinedPid");
-
- for(Int_t iPart=0; iPart<kNParticles; iPart++){
-   mcPidList->Add(fHistMcPid[iPart]);
-   mcPidList->Add(fHistEsdPid[iPart]);
- }
-}
-
-
-//_______________________________________________________________________________________________
-void AliHFEdca::CreateHistogramsDataPid(TList *pidList){
- //
- // define histograms which fills combined PID: data
- //
-
-
-
- for(Int_t iPart=0; iPart<kNParticles; iPart++){
-     TString histTitleEsd((const char*)fgkParticles[iPart]);
-     histTitleEsd+=Form("_DataEsdPid_esdPt;p_{T} [GeV/c];counts");
-     TString histNameEsd((const char*)fgkParticles[iPart]);
-     histNameEsd+=Form("_DataEsdPid");
-
-     fHistDataEsdPid[iPart] = new TH1F(histNameEsd, histTitleEsd, kNPtBins, fgkPtIntv);
- }
-
-
- pidList->SetOwner();
- pidList->SetName("dataCombinedPid");
-
- for(Int_t iPart=0; iPart<kNParticles; iPart++)
-   pidList->Add(fHistDataEsdPid[iPart]);
-
-
-}
-
-
-
-//_______________________________________________________________________________________________
-void AliHFEdca::FillHistogramsDca(const AliESDEvent * const esdEvent, const AliESDtrack * const track, AliMCEvent * const mcEvent)
-{
- // the kDca plugin
- // MC vertex
- AliMCVertex *mcPrimVtx = (AliMCVertex *)mcEvent->GetPrimaryVertex();      
- Double_t mcPrimV[3];
- mcPrimV[0] = mcPrimVtx->GetX();
- mcPrimV[1] = mcPrimVtx->GetY();
- mcPrimV[2] = mcPrimVtx->GetZ();
-
- Double_t mcVtxXY = TMath::Abs(mcPrimV[0]*mcPrimV[0] + mcPrimV[1]*mcPrimV[1]);
-
-// filling historgams track by track
-// obtaining reconstructed dca ------------------------------------------------------------------
-
- Float_t esdpx = track->Px();
- Float_t esdpy = track->Py();
- Float_t esdpt = TMath::Sqrt(esdpx*esdpx+esdpy*esdpy);  
-
-// obtaining errors of dca ------------------------------------------------------------------
- const AliESDVertex *primVtx = esdEvent->GetPrimaryVertex();      
- Double_t primV[3];
- primV[0] = primVtx->GetXv();
- primV[1] = primVtx->GetYv();
- primV[2] = primVtx->GetZv();
-
- Float_t magneticField = 0;  // initialized as 5kG
- magneticField = esdEvent->GetMagneticField();  // in kG
-
- Double_t beampiperadius=3.;
- Double_t dz[2];   // error of dca in cm
- Double_t covardz[3];
-
- AliESDtrack ctrack(*track);
- if(!ctrack.PropagateToDCA(primVtx,magneticField, beampiperadius, dz, covardz)) return;  // protection
-
- AliMCParticle *mctrack = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(track->GetLabel()))); 
- if(!mctrack) return;
- TParticle *part = mctrack->Particle();
-
- Float_t vx = part->Vx();  // in cm
- Float_t vy = part->Vy();  // in cm
- Float_t vz = part->Vz();   // in cm
-
- Float_t vxy = TMath::Sqrt(vx*vx+vy*vy);
-
- Float_t mcpx = part->Px();
- Float_t mcpy = part->Py();
- Float_t mcpt = TMath::Sqrt(mcpx*mcpx+mcpy*mcpy);
-
- Int_t pdg = part->GetPdgCode();
- Int_t esdPid = GetCombinedPid(track);
-
- Int_t charge = 1;
- if(pdg==kPDGelectron || pdg==kPDGmuon 
-    || pdg==-kPDGpion || pdg==-kPDGkaon || pdg==-kPDGproton) charge = -1;  
-
- // calculate mcDca ------------------------------------------------------------------ 
- const Float_t conv[2] = {1.783/1.6, 2.99792458};
- Float_t radiusMc = mcpt/(TMath::Abs(magneticField)/10.)*conv[0]*conv[1]; // pt in GeV/c, magnetic field in Tesla, radius in meter
-
- Float_t nx = esdpx/mcpt;
- Float_t ny = esdpy/mcpt;
-
- Float_t radius;
- radius = TMath::Abs(radiusMc);
-
- Double_t dxy = vxy - mcVtxXY;   // in cm
- Double_t dvx = vx - mcPrimV[0]; // in cm
- Double_t dvy = vy - mcPrimV[1]; // in cm
-
- Float_t mcDcaXY = (radius - TMath::Sqrt(dxy*dxy/100./100. + radius*radius + 2*radius*charge*(dvx*ny-dvy*nx)/100.)) ;  // in meters
-
- Double_t mcDca[2] = {mcDcaXY*100, vz};  // in cm
- Double_t residual[2] = {0, 0};
- Double_t pull[2] = {0, 0};
- Double_t error[2] ={TMath::Sqrt(covardz[0]), TMath::Sqrt(covardz[2])};
- for(Int_t i=0; i<2; i++){
-   residual[i] = dz[i] - mcDca[i]; // in centimeters       
-   if(error[i]!=0)pull[i] = residual[i]/error[i];   // unitless
- }
-
-
- for(Int_t iPart=0; iPart<(kNParticles-2); iPart++){    
-   // identified ones
-   for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-     if(esdpt>fgkPtIntv[iPtBin] && esdpt<=fgkPtIntv[iPtBin+1]){
-       if(pdg==fgkPdgParticle[iPart]) {
-         fHistDcaXYRes[iPart][iPtBin]->Fill(residual[0]*1.0e4);  
-         fHistDcaZRes[iPart][iPtBin]->Fill(residual[1]*1.0e4);   
-         fHistDcaXYPull[iPart][iPtBin]->Fill(pull[0]);  
-         fHistDcaZPull[iPart][iPtBin]->Fill(pull[1]); 
-         fHistDcaXY[iPart][iPtBin]->Fill(dz[0]*1.0e4); 
-         fHistDcaZ[iPart][iPtBin]->Fill(dz[1]*1.0e4);  
-       }  // mc pdg      
-       
-       if(esdPid==fgkPdgParticle[iPart]) {
-         fHistEPDcaXYRes[iPart][iPtBin]->Fill(residual[0]*1.0e4);  
-         fHistEPDcaZRes[iPart][iPtBin]->Fill(residual[1]*1.0e4);   
-         fHistEPDcaXYPull[iPart][iPtBin]->Fill(pull[0]);  
-         fHistEPDcaZPull[iPart][iPtBin]->Fill(pull[1]); 
-         fHistEPDcaXY[iPart][iPtBin]->Fill(dz[0]*1.0e4); 
-         fHistEPDcaZ[iPart][iPtBin]->Fill(dz[1]*1.0e4);  
-       }  // esd pid
-       
-     } // pt range
-
-     else
-       continue;
-   }  // pt loop
- } // particle id loop
-
- // for charged particles: no pid
- for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-   if(esdpt>fgkPtIntv[iPtBin] && esdpt<=fgkPtIntv[iPtBin+1]){
-     Int_t iPart = 10;
-     if(charge>0) iPart = 11;
-     fHistDcaXYRes[iPart][iPtBin]->Fill(residual[0]*1e4);
-     fHistDcaZRes[iPart][iPtBin]->Fill(residual[1]*1e4);
-     fHistDcaXYPull[iPart][iPtBin]->Fill(pull[0]);
-     fHistDcaZPull[iPart][iPtBin]->Fill(pull[1]);
-     fHistDcaXY[iPart][iPtBin]->Fill(dz[0]*1e4);
-     fHistDcaZ[iPart][iPtBin]->Fill(dz[1]*1e4);      
-   }
-   else
-     continue;
- } // pt  
-
-}
-
-//_______________________________________________________________________________________________
-void AliHFEdca::FillHistogramsKfDca(const AliESDEvent * const esdEvent, const AliESDtrack * const track, const AliMCEvent * const mcEvent)
- {
- // the kKfDca plugin
-
-// filling historgams track by track
-
-// obtaining reconstructed dca ------------------------------------------------------------------  
- const AliESDVertex *primVtx = esdEvent->GetPrimaryVertex();      
-   Float_t magneticField = 0;  // initialized as 5kG
- magneticField = esdEvent->GetMagneticField();  // in kG
-
- Float_t esdpx = track->Px();
- Float_t esdpy = track->Py();
- Float_t esdpt = TMath::Sqrt(esdpx*esdpx+esdpy*esdpy);  
-
- Int_t charge = track->Charge();
-
- Double_t beampiperadius=3.;  
- Double_t dz[2];   // error of dca in cm
- Double_t covardz[3];
- AliESDtrack ctrack(*track);
- if(!ctrack.PropagateToDCA(primVtx,magneticField, beampiperadius, dz, covardz)) return; // protection 
-
- AliMCParticle *mctrack = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(track->GetLabel())));  
- if(!mctrack) return;
- TParticle *part = mctrack->Particle();    
- Int_t pdg = part->GetPdgCode();
-
- // calculate dca using AliKFParticle class------------------------------------------------------------------
- Double_t kfdz[3] = {0, 0, 0};  
- Double_t kfdzwith[3] = {0, 0, 0};  
-
- Int_t trkID = track->GetID();
-
- AliKFParticle::SetField(magneticField);
- AliKFParticle kfParticle(*track, pdg);
-
- // prepare kfprimary vertex
- AliKFVertex kfESDprimary;
- // Reconstruct Primary Vertex (with ESD tracks)
- Int_t n=primVtx->GetNIndices();
- if (n>0 && primVtx->GetStatus()){
-   kfESDprimary = AliKFVertex(*primVtx);
-
-   Double_t dcaXYWithTrk = kfParticle.GetDistanceFromVertexXY(kfESDprimary);
-   Double_t dcaWithTrk = kfParticle.GetDistanceFromVertex(kfESDprimary);
-   Double_t dcaZWithTrk = 0;
-   if(TMath::Abs(dcaWithTrk)>=TMath::Abs(dcaXYWithTrk)) 
-     dcaZWithTrk =TMath::Sqrt(dcaWithTrk*dcaWithTrk-dcaXYWithTrk*dcaXYWithTrk)*((dz[1]*-1<=0)?1:-1);
-   kfdzwith[0] = dcaXYWithTrk;  
-   kfdzwith[1] = dcaZWithTrk; 
-   kfdzwith[2] = dcaWithTrk;  // with current track
-
-   Double_t dcaXYWoTrk = 0;
-   Double_t dcaZWoTrk = 0;
-   Double_t dcaWoTrk = 0;
-
-   UShort_t *priIndex = primVtx->GetIndices();
-
-   for (Int_t i=0;i<n;i++){
-
-     Int_t idx = Int_t(priIndex[i]);
-     if (idx == trkID){
-       kfESDprimary -= kfParticle;
-       dcaXYWoTrk = kfParticle.GetDistanceFromVertexXY(kfESDprimary);
-       dcaWoTrk = kfParticle.GetDistanceFromVertex(kfESDprimary);
-       if((dcaWoTrk-dcaXYWoTrk)>=0)
-         dcaZWoTrk = TMath::Abs(dcaWoTrk*dcaWoTrk - dcaXYWoTrk*dcaXYWoTrk)*((dz[1]*-1<=0)?1:-1);
-     }  // remove current track from this calculation
-   }  // loop over all primary vertex contributors
-
-
-   kfdz[0] = dcaXYWoTrk;  
-   kfdz[1] = dcaZWoTrk;
-   kfdz[2] = dcaWoTrk;  
-
- }  // only if n contributor > 0 and primVtx constructed
-
- fStat->Fill(0);
-
- if(dz[0]!=0 && dz[0]*kfdzwith[0]>0 && TMath::Abs(kfdzwith[0]/dz[0])>0.9999 && TMath::Abs(kfdzwith[0]/dz[0])<1.0001)fStat->Fill(1);; // same 
- if(dz[0]!=0 && dz[0]*kfdzwith[0]<0 && TMath::Abs(kfdzwith[0]/dz[0])>0.9999 && TMath::Abs(kfdzwith[0]/dz[0])<1.0001) fStat->Fill(2); // swapped sign
- if(kfdzwith[0]==0 && dz[0]!=0) fStat->Fill(3);  // 0 from KF particle (with current track)
-
- if(dz[0]!=0 && dz[0]*kfdz[0]>0 && TMath::Abs(kfdz[0]/dz[0])>0.8 && TMath::Abs(kfdz[0]/dz[0])<1.2) fStat->Fill(-1);; // same 
- if(dz[0]!=0 && dz[0]*kfdz[0]<0 && TMath::Abs(kfdz[0]/dz[0])>0.8 && TMath::Abs(kfdz[0]/dz[0]) <1.2) fStat->Fill(-2); // swapped sign
- if(kfdz[0]==0 && dz[0]!=0) fStat->Fill(-3);  // 0 from KF particle (without current track)
-
- for(Int_t iPart=0; iPart<(kNParticles-2); iPart++){    
-   // identified ones
-   for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-     if(esdpt>fgkPtIntv[iPtBin] && esdpt<=fgkPtIntv[iPtBin+1]){
-       if(pdg==fgkPdgParticle[iPart]) {
-         fHistKFDcaXY[iPart][iPtBin]->Fill(kfdzwith[0]*1.0e4); 
-         fHistKFDcaZ[iPart][iPtBin]->Fill(kfdzwith[1]*1.0e4);  
-       }  // mc pdg      
-     } // pt range
-
-     else
-       continue;
-   }  // pt loop
- } // particle id loop
-
- // for charged particles: no pid
- for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-   if(esdpt>fgkPtIntv[iPtBin] && esdpt<=fgkPtIntv[iPtBin+1]){
-     Int_t iPart = 10;
-     if(charge>0) iPart = 11;
-     fHistKFDcaXY[iPart][iPtBin]->Fill(kfdzwith[0]*1e4);
-     fHistKFDcaZ[iPart][iPtBin]->Fill(kfdzwith[1]*1e4);
-
-   }
-   else
-     continue;
- } // pt  
-
-}  // KF dca
-
-
-//_______________________________________________________________________________________________
-void AliHFEdca::FillHistogramsVtx(const AliESDEvent *const esdEvent, const AliMCEvent *const mcEvent)
-{
-
- // MC vertex
- AliMCVertex *mcPrimVtx = (AliMCVertex *)mcEvent->GetPrimaryVertex();      
- Double_t mcPrimV[3];
- mcPrimV[0] = mcPrimVtx->GetX();
- mcPrimV[1] = mcPrimVtx->GetY();
- mcPrimV[2] = mcPrimVtx->GetZ();
-
-// obtaining errors of dca ------------------------------------------------------------------
- const AliESDVertex *primVtx = esdEvent->GetPrimaryVertex();      
- Double_t primV[3];
- primV[0] = primVtx->GetXv();
- primV[1] = primVtx->GetYv();
- primV[2] = primVtx->GetZv();
-
- for(Int_t i=0; i<kNVertexVar; i++){
-   fHistMCvertex[i]->Fill(mcPrimV[i]*1.0e4); 
-   fHistESDvertex[i]->Fill(primV[i]*1.0e4); 
- }
-
-}
-
-//_______________________________________________________________________________________________
-void AliHFEdca::FillHistogramsPid(const AliESDtrack * const track, const AliMCEvent * const mcEvent)
-{
-
-
-// filling historgams track by track
- Float_t esdpx = track->Px();
- Float_t esdpy = track->Py();
- Float_t esdpt = TMath::Sqrt(esdpx*esdpx+esdpy*esdpy);    
-
- AliMCParticle *mctrack = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(track->GetLabel())));  
- if(!mctrack) return;
- TParticle *part = mctrack->Particle();
-
- Float_t mcpx = part->Px();
- Float_t mcpy = part->Py();
- Float_t mcpt = TMath::Sqrt(mcpx*mcpx+mcpy*mcpy);
-
- Int_t pdg = part->GetPdgCode();
- Int_t esdPid = GetCombinedPid(track);
-
-
- Double_t ptMom[2] = {mcpt, esdpt};
- // for combined PID
- for(Int_t iPart=0; iPart<(kNParticles-2); iPart++){
-   if(pdg==fgkPdgParticle[iPart])                // pid all by MC 
-     fHistMcPid[iPart]->Fill(ptMom[0]);
-
-   if(esdPid==fgkPdgParticle[iPart])             // pid all by combined pid
-     fHistEsdPid[iPart]->Fill(ptMom[1]);    
- } // loop over particles
-
- // for charged
- if(pdg==kPDGelectron || pdg==kPDGmuon || pdg==-kPDGpion || pdg==-kPDGkaon || pdg==-kPDGproton)
-   fHistMcPid[10]->Fill(ptMom[0]);
- if(pdg==-kPDGelectron || pdg==-kPDGmuon || pdg==kPDGpion || pdg==kPDGkaon || pdg==kPDGproton)
-   fHistMcPid[11]->Fill(ptMom[0]);
- if(esdPid==kPDGelectron || esdPid==kPDGmuon || esdPid==-kPDGpion || esdPid==-kPDGkaon || esdPid==-kPDGproton)
-   fHistEsdPid[10]->Fill(ptMom[1]);  
- if(esdPid==-kPDGelectron || esdPid==-kPDGmuon || esdPid==kPDGpion || esdPid==kPDGkaon || esdPid==kPDGproton)
-   fHistEsdPid[11]->Fill(ptMom[1]);  
-}
-
-
-////_______________________________________________________________________________________________
-void AliHFEdca::FillHistogramsDataDca(const AliESDEvent * const esdEvent, const AliESDtrack * const track, const AliESDVertex * const vtxESDSkip)
-{
-// filling historgams track by track
-// obtaining reconstructed dca --------------------------------------------------------------
-
- Float_t esdpx = track->Px();
- Float_t esdpy = track->Py();
- Float_t esdpt = TMath::Sqrt(esdpx*esdpx+esdpy*esdpy);  
- Int_t charge = track->Charge();
-
-// obtaining errors of dca ------------------------------------------------------------------
- const AliESDVertex *primVtx = esdEvent->GetPrimaryVertex();      
- Double_t primV[3];
- primV[0] = primVtx->GetXv();
- primV[1] = primVtx->GetYv();
- primV[2] = primVtx->GetZv();
-
-
- Float_t magneticField = 0;  // initialized as 5kG
- magneticField = esdEvent->GetMagneticField();  // in kG
-
- Double_t beampiperadius=3.;
- Double_t dz[2];   // error of dca in cm
- Double_t covardz[3];
-
- AliESDtrack ctrack(*track);
- if(!ctrack.PropagateToDCA(primVtx,magneticField, beampiperadius, dz, covardz)) return;  // protection
-
-
- Double_t pull[2] = {0, 0};
- Double_t error[2] ={TMath::Sqrt(covardz[0]), TMath::Sqrt(covardz[2])};
- for(Int_t i=0; i<2; i++){
-   if(error[i]!=0)pull[i] = dz[i]/error[i];   // unitless                                                
- }
-
- // get dca when current track is not included
-
- Double_t dzwo[2], covardzwo[3];
- Double_t pullwo[2] = {0, 0};
- if(!ctrack.PropagateToDCA(vtxESDSkip, magneticField, beampiperadius, dzwo, covardzwo)) return;   // protection
-
- Double_t errorwo[2] ={TMath::Sqrt(TMath::Abs(covardzwo[0])), TMath::Sqrt(TMath::Abs(covardzwo[2]))};
- for(Int_t i=0; i<2; i++){
-   if(errorwo[i]!=0) pullwo[i] = dzwo[i]/errorwo[i];   // unitless                                                
- }
-
- // do pid 
- Int_t esdPid = GetCombinedPid(track);
-
- for(Int_t iPart=0; iPart<(kNParticles-2); iPart++){    
-   // identified ones
-   for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-     if(esdPid==fgkPdgParticle[iPart] && (esdpt>fgkPtIntv[iPtBin] && esdpt<=fgkPtIntv[iPtBin+1])) {
-       fHistDataDcaXY[iPart][iPtBin]->Fill(dz[0]*1e4);
-       fHistDataDcaZ[iPart][iPtBin]->Fill(dz[1]*1e4);      
-       fHistDataDcaXYPull[iPart][iPtBin]->Fill(pull[0]);
-       fHistDataDcaZPull[iPart][iPtBin]->Fill(pull[1]);        
-       // w/o current track
-       fHistDataWoDcaXY[iPart][iPtBin]->Fill(dzwo[0]*1e4);
-       fHistDataWoDcaZ[iPart][iPtBin]->Fill(dzwo[1]*1e4);      
-       fHistDataWoDcaXYPull[iPart][iPtBin]->Fill(pullwo[0]);
-       fHistDataWoDcaZPull[iPart][iPtBin]->Fill(pullwo[1]);    
-     }
-     else
-       continue;
-   }
- } 
-
- // for charged particles
- for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-   if(esdpt>fgkPtIntv[iPtBin] && esdpt<=fgkPtIntv[iPtBin+1]){
-     Int_t iPart = 10;
-     if(charge>0) iPart = 11;
-     fHistDataDcaXY[iPart][iPtBin]->Fill(dz[0]*1e4);
-     fHistDataDcaZ[iPart][iPtBin]->Fill(dz[1]*1e4);      
-     fHistDataDcaXYPull[iPart][iPtBin]->Fill(pull[0]);
-     fHistDataDcaZPull[iPart][iPtBin]->Fill(pull[1]);
-     // without current track
-     fHistDataWoDcaXY[iPart][iPtBin]->Fill(dzwo[0]*1e4);
-     fHistDataWoDcaZ[iPart][iPtBin]->Fill(dzwo[1]*1e4);      
-     fHistDataWoDcaXYPull[iPart][iPtBin]->Fill(pullwo[0]);
-     fHistDataWoDcaZPull[iPart][iPtBin]->Fill(pullwo[1]);      
-
-   }
-   else
-     continue;
- } 
-
-}
-
-//_______________________________________________________________________________________________
-void AliHFEdca::FillHistogramsDataVtx(const AliESDEvent * const esdEvent)
-{
-
-
-// obtaining errors of dca ------------------------------------------------------------------
- const AliESDVertex *primVtx = esdEvent->GetPrimaryVertex();      
- Double_t primV[3];
- primV[0] = primVtx->GetXv();
- primV[1] = primVtx->GetYv();
- primV[2] = primVtx->GetZv();
-
- // require events with at least 3 contributors for primary vertex construction
- Int_t nEsdPrimVtxCtrb = primVtx->GetNContributors(); 
- if(nEsdPrimVtxCtrb<1) return; // for pass 1, no diomond constrain, each event has at least 1 contributor to Vtx
- for(Int_t i=0; i<kNVertexVar; i++)
-   fHistDatavertex[i]->Fill(primV[i]*1e4);
-
-}
-
-
-////_______________________________________________________________________________________________
-void AliHFEdca::FillHistogramsDataPid(const AliESDtrack * const track)
-{
-// filling historgams track by track
-// obtaining reconstructed dca --------------------------------------------------------------
-
- Float_t esdpx = track->Px();
- Float_t esdpy = track->Py();
- Float_t esdpt = TMath::Sqrt(esdpx*esdpx+esdpy*esdpy);  
- Int_t charge = track->Charge();
-
- Int_t esdPid = GetCombinedPid(track);
-
- for(Int_t iPart=0; iPart<kNParticles; iPart++){
-   if(iPart<(kNParticles-2)){
-     if(esdPid==fgkPdgParticle[iPart])  fHistDataEsdPid[iPart]->Fill(esdpt);
-   }     // for identified
-
-   else {
-     if(charge<0) fHistDataEsdPid[10]->Fill(esdpt);
-     if(charge>0) fHistDataEsdPid[11]->Fill(esdpt);
-   }
- }
-}  
-
-//_________________________________________________________________________________________________
-void AliHFEdca::ApplyExtraCuts(const AliESDEvent * const esdEvent, Int_t nMinPrimVtxContributor)
-{ 
-
- //
- // only one extra cut, number of contributors to each primary vertex
- //
-
- const AliESDVertex *primVtx = esdEvent->GetPrimaryVertex();      
- Int_t nEsdPrimVtxCtrb = primVtx->GetNContributors(); 
- if(nEsdPrimVtxCtrb<nMinPrimVtxContributor) return; 
- // for pass 1, no diomond constrain, each event has at least 1 contributor to Vtx
-
-}
-
-//_____________________________________________________
-Int_t AliHFEdca::GetCombinedPid(const AliESDtrack *const track) 
-{
-
- // combined detector pid             
- Double_t prob[AliPID::kSPECIES];
- track->GetESDpid(prob);
-
- // setting priors!
- Double_t priors[AliPID::kSPECIES];
- priors[0] = 0.01;
- priors[1] = 0.01;
- priors[2] = 0.85;
- priors[3] = 0.10;
- priors[4] = 0.05;
-
- Int_t charge = track->Charge();
- Int_t esdPid = -1; 
-
- AliPID pid;
- pid.SetPriors(priors);
- pid.SetProbabilities(prob);
-
- // identify particle as the most probable 
-
- Double_t pelectron = pid.GetProbability(AliPID::kElectron);
- if(pelectron > pid.GetProbability(AliPID::kMuon) && 
-    pelectron > pid.GetProbability(AliPID::kPion) && 
-    pelectron > pid.GetProbability(AliPID::kKaon) && 
-    pelectron > pid.GetProbability(AliPID::kProton) )  esdPid = -kPDGelectron; 
-
- Double_t pmuon = pid.GetProbability(AliPID::kMuon);
- if(pmuon > pid.GetProbability(AliPID::kElectron) && 
-    pmuon > pid.GetProbability(AliPID::kPion) && 
-    pmuon > pid.GetProbability(AliPID::kKaon) && 
-    pmuon > pid.GetProbability(AliPID::kProton) )  esdPid = -kPDGmuon; 
-
- Double_t ppion = pid.GetProbability(AliPID::kPion);
- if(ppion > pid.GetProbability(AliPID::kElectron) && 
-    ppion > pid.GetProbability(AliPID::kMuon) && 
-    ppion > pid.GetProbability(AliPID::kKaon) && 
-    ppion > pid.GetProbability(AliPID::kProton) )  esdPid = kPDGpion; 
-
- Double_t pkaon = pid.GetProbability(AliPID::kKaon);
- if(pkaon > pid.GetProbability(AliPID::kElectron) && 
-    pkaon > pid.GetProbability(AliPID::kMuon) && 
-    pkaon > pid.GetProbability(AliPID::kPion) && 
-    pkaon > pid.GetProbability(AliPID::kProton) )  esdPid = kPDGkaon; 
-
- Double_t pproton = pid.GetProbability(AliPID::kProton);
- if(pproton > pid.GetProbability(AliPID::kElectron) && 
-    pproton > pid.GetProbability(AliPID::kMuon) && 
-    pproton > pid.GetProbability(AliPID::kPion) && 
-    pproton > pid.GetProbability(AliPID::kKaon) )  esdPid = kPDGproton; 
-
-
- return charge*esdPid;
-
-}
-
-
-// for the HFE pid
-
-//________________________________________________________________________
-void AliHFEdca::CreateHistogramsHfeDca(TList *hfeDcaList){
- //
- // define histograms: hfe pid electrons in MC
- //
-
- const Int_t nBinsDca = 1000;
- const Float_t maxXYBinDca = 1000.;
- const Float_t maxZBinDca = 1000.;
-
- const Int_t nBinsPull = 1000;
- const Float_t maxXYBinPull = 20.;
- const Float_t maxZBinPull = 20.;
-
- const Char_t *mcOResd[2]={"mcPt", "esdPt"};
-
-//  fHistHPDcaXY[2][kNPtBins]=0x0;
-//  fHistHPDcaZ[2][kNPtBins]=0x0;
-//  fHistHPDcaXYRes[2][kNPtBins]=0x0;
-//  fHistHPDcaZRes[2][kNPtBins]=0x0;
-//  fHistHPDcaXYPull[2][kNPtBins]=0x0;
-//  fHistHPDcaZPull[2][kNPtBins]=0x0;
-
-
- for(Int_t k=0; k<kNDcaVar; k++){
-
-   TString histTitleDca((const char*)fgkDcaVarTitle[k]);
-   TString histTitleRes((const char*)fgkPullDcaVarTitle[k]);
-   TString histTitlePull((const char*)fgkResDcaVarTitle[k]);
-
-   for(Int_t iPart=0; iPart<2; iPart++){
-     for(Int_t i=0; i<kNPtBins; i++){          
-       TString histHPName((const char*)fgkParticles[iPart*5]);
-       histHPName += Form("_HFEpid_%s_pT-%.2f-%.2f", (const char*)fgkDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-       TString histHPNameRes((const char*)fgkParticles[iPart*5]);
-       histHPNameRes += Form("_HFEpid_%s_pT-%.2f-%.2f", (const char*)fgkResDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-       TString histHPNamePull((const char*)fgkParticles[iPart*5]);
-       histHPNamePull += Form("_HFEpid_%s_pT-%.2f-%.2f", (const char*)fgkPullDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-       
-       if(k==0){
-         fHistHPDcaXY[iPart][i] = new TH1F((const char*)histHPName, (const char*)histTitleDca, nBinsDca, 1-maxXYBinDca, 1+maxXYBinDca);
-         fHistHPDcaXY[iPart][i]->SetLineColor((int)fgkColorPart[iPart*5]);
-         fHistHPDcaXYRes[iPart][i] = new TH1F((const char*)histHPNameRes, (const char*)histTitleRes, nBinsDca, 1-maxXYBinDca, 1+maxXYBinDca);
-         fHistHPDcaXYRes[iPart][i]->SetLineColor((int)fgkColorPart[iPart*5]);
-         fHistHPDcaXYPull[iPart][i] = new TH1F((const char*)histHPNamePull, (const char*)histTitlePull, nBinsPull, 1-maxXYBinPull, 1+maxXYBinPull);
-         fHistHPDcaXYPull[iPart][i]->SetLineColor((int)fgkColorPart[iPart*5]);
-       }
-       
-       if(k==1){
-         fHistHPDcaZ[iPart][i] = new TH1F((const char*)histHPName, (const char*)histTitleDca, nBinsDca, 1-maxZBinDca, 1+maxZBinDca);
-         fHistHPDcaZ[iPart][i]->SetLineColor((int)fgkColorPart[iPart*5]);
-         fHistHPDcaZRes[iPart][i] = new TH1F((const char*)histHPNameRes, (const char*)histTitleRes, nBinsDca, 1-maxZBinDca, 1+maxZBinDca);
-         fHistHPDcaZRes[iPart][i]->SetLineColor((int)fgkColorPart[iPart*5]);
-         fHistHPDcaZPull[iPart][i] = new TH1F((const char*)histHPNamePull, (const char*)histTitlePull, nBinsPull, 1-maxZBinPull, 1+maxZBinPull);
-         fHistHPDcaZPull[iPart][i]->SetLineColor((int)fgkColorPart[iPart*5]);
-       }
-     } // 50 pt bins
-   } //2 nparticles
- } // 2 dca var
-
- // fHistHfePid[2][2] = 0x0; //!  HFE pid  
- for(Int_t id=0; id<2; id++){
-   for(Int_t iPart=0; iPart<2; iPart++){
-     TString histTitleHfe((const char*)fgkParticles[iPart*5]);
-     histTitleHfe+=Form("_MC_HfePid_esdPt;p_{T} [GeV/c];counts");
-     TString histNameHfe((const char*)fgkParticles[iPart*5]);
-     histNameHfe+=Form("_MC_HfePid_%s", mcOResd[id]);
-     fHistHfePid[id][iPart] = new TH1F(histNameHfe, histTitleHfe, kNPtBins, fgkPtIntv);
-   }
- }  
-
- hfeDcaList->SetOwner();
- hfeDcaList->SetName("hfeDca");
- for(Int_t iPart=0; iPart<2; iPart++){
-   for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-     hfeDcaList->Add(fHistHPDcaXY[iPart][iPtBin]);  
-     hfeDcaList->Add(fHistHPDcaZ[iPart][iPtBin]); 
-     hfeDcaList->Add(fHistHPDcaXYRes[iPart][iPtBin]);  
-     hfeDcaList->Add(fHistHPDcaZRes[iPart][iPtBin]); 
-     hfeDcaList->Add(fHistHPDcaXYPull[iPart][iPtBin]);  
-     hfeDcaList->Add(fHistHPDcaZPull[iPart][iPtBin]);
-   }
-   for(Int_t id=0; id<2; id++)
-     hfeDcaList->Add(fHistHfePid[id][iPart]);
- }
-
-}
-
-
-//________________________________________________________________________
-void AliHFEdca::CreateHistogramsHfeDataDca(TList *hfeDataDcaList){
- //
- // define histograms: hfe pid electrons in data
- //
-
- const Int_t nBinsDca = 1000;
- const Float_t maxXYBinDca = 1000.;
- const Float_t maxZBinDca = 1000.;
-
- const Int_t nBinsPull = 1000;
- const Float_t maxXYBinPull = 20.;
- const Float_t maxZBinPull = 20.;
-
-
-//  fHistHPDataDcaXY[2][kNPtBins]=0x0;
-//  fHistHPDataDcaZ[2][kNPtBins]=0x0;
-//  fHistHPDataDcaXYPull[2][kNPtBins]=0x0;
-//  fHistHPDataDcaZPull[2][kNPtBins]=0x0;
-
- for(Int_t k=0; k<kNDcaVar; k++){
-   TString histTitleDca((const char*)fgkDcaVarTitle[k]);
-   TString histTitlePull((const char*)fgkPullDcaVarTitle[k]);
-   for(Int_t iPart=0; iPart<2; iPart++){
-     for(Int_t i=0; i<kNPtBins; i++){          
-       TString histHPName((const char*)fgkParticles[iPart*5]);
-       histHPName += Form("_HFEpid_%s_pT-%.2f-%.2f", (const char*)fgkDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-       TString histHPNamePull((const char*)fgkParticles[iPart*5]);
-       histHPNamePull += Form("_HFEpid_%s_pT-%.2f-%.2f", (const char*)fgkPullDcaVar[k], fgkPtIntv[i], fgkPtIntv[i+1]);
-       
-       if(k==0){
-         fHistHPDataDcaXY[iPart][i] = new TH1F((const char*)histHPName, (const char*)histTitleDca, nBinsDca, 1-maxXYBinDca, 1+maxXYBinDca);
-         fHistHPDataDcaXY[iPart][i]->SetLineColor((int)fgkColorPart[iPart*5]);
-         fHistHPDataDcaXYPull[iPart][i] = new TH1F((const char*)histHPNamePull, (const char*)histTitlePull, nBinsPull, 1-maxXYBinPull, 1+maxXYBinPull);
-         fHistHPDataDcaXYPull[iPart][i]->SetLineColor((int)fgkColorPart[iPart*5]);
-       }
-       
-       if(k==1){
-         fHistHPDataDcaZ[iPart][i] = new TH1F((const char*)histHPName, (const char*)histTitleDca, nBinsDca, 1-maxZBinDca, 1+maxZBinDca);
-         fHistHPDataDcaZ[iPart][i]->SetLineColor((int)fgkColorPart[iPart*5]);
-         fHistHPDataDcaZPull[iPart][i] = new TH1F((const char*)histHPNamePull, (const char*)histTitlePull, nBinsDca, 1-maxZBinPull, 1+maxZBinPull);
-         fHistHPDataDcaZPull[iPart][i]->SetLineColor((int)fgkColorPart[iPart*5]);
-       }
-       
-     } // 50 pt bins
-   } // 2 particle type
- } // 2 dca var
-
- //fHistDataHfePid[2] = 0x0; //!  HFE pid  
- for(Int_t iPart=0; iPart<2; iPart++){
-   TString histTitleHfe((const char*)fgkParticles[iPart*5]);
-   histTitleHfe+=Form("_Data_HfePid_esdPt;p_{T} [GeV/c];counts");
-   TString histNameHfe((const char*)fgkParticles[iPart*5]);
-   histNameHfe+=Form("_Data_HfePid");
-   fHistDataHfePid[iPart] = new TH1F(histNameHfe, histTitleHfe, kNPtBins, fgkPtIntv);
- }
-
-
- hfeDataDcaList->SetOwner();
- hfeDataDcaList->SetName("hfeDataDca");
- for(Int_t iPart=0; iPart<2; iPart++){
-   for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-     hfeDataDcaList->Add(fHistHPDataDcaXY[iPart][iPtBin]);  
-     hfeDataDcaList->Add(fHistHPDataDcaZ[iPart][iPtBin]); 
-     hfeDataDcaList->Add(fHistHPDataDcaXYPull[iPart][iPtBin]);  
-     hfeDataDcaList->Add(fHistHPDcaZPull[iPart][iPtBin]); 
-
-     hfeDataDcaList->Add(fHistDataHfePid[iPart]);
-   }
- }
-
-
-}
-
-
-//_______________________________________________________________________________________________
-void AliHFEdca::FillHistogramsHfeDca(const AliESDEvent * const esdEvent, const AliESDtrack * const track, const AliMCEvent * const mcEvent)
-{
- // the kHFEpid plugin
-
- AliMCVertex *mcPrimVtx = (AliMCVertex *)mcEvent->GetPrimaryVertex();      
- Double_t mcPrimV[3];
- mcPrimV[0] = mcPrimVtx->GetX();
- mcPrimV[1] = mcPrimVtx->GetY();
- mcPrimV[2] = mcPrimVtx->GetZ();
-
- Double_t mcVtxXY = TMath::Abs(mcPrimV[0]*mcPrimV[0] + mcPrimV[1]*mcPrimV[1]);
-
-// filling historgams track by track
-// obtaining reconstructed dca ------------------------------------------------------------------
- Float_t esdpx = track->Px();
- Float_t esdpy = track->Py();
- Float_t esdpt = TMath::Sqrt(esdpx*esdpx+esdpy*esdpy);  
-
-// obtaining errors of dca ------------------------------------------------------------------
- const AliESDVertex *primVtx = esdEvent->GetPrimaryVertex();      
- Double_t primV[3];
- primV[0] = primVtx->GetXv();
- primV[1] = primVtx->GetYv();
- primV[2] = primVtx->GetZv();
-
- Float_t magneticField = 0;  // initialized as 5kG
- magneticField = esdEvent->GetMagneticField();  // in kG
-
- Double_t beampiperadius=3.;
- Double_t dz[2];   // error of dca in cm
- Double_t covardz[3];
- AliESDtrack ctrack(*track);
- if(!ctrack.PropagateToDCA(primVtx,magneticField, beampiperadius, dz, covardz)) return; // protection
-
- AliMCParticle *mctrack = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(track->GetLabel())));  
- if(!mctrack) return;
- TParticle *part = mctrack->Particle();
-
- Float_t vx = part->Vx();  // in cm
- Float_t vy = part->Vy();  // in cm
- Float_t vz = part->Vz();   // in cm
-
- Float_t vxy = TMath::Sqrt(vx*vx+vy*vy);
-
- Float_t mcpx = part->Px();
- Float_t mcpy = part->Py();
- Float_t mcpt = TMath::Sqrt(mcpx*mcpx+mcpy*mcpy);
-
- Int_t pdg = part->GetPdgCode();
-
- Int_t charge = 1;
- if(pdg==kPDGelectron || pdg==kPDGmuon 
-    || pdg==-kPDGpion || pdg==-kPDGkaon || pdg==-kPDGproton) charge = -1;
-
- // calculate mcDca ------------------------------------------------------------------ 
- const Float_t conv[2] = {1.783/1.6, 2.99792458};
- Float_t radiusMc = mcpt/(TMath::Abs(magneticField)/10.)*conv[0]*conv[1]; // pt in GeV/c, magnetic field in Tesla, radius in meter
-
- Float_t nx = esdpx/mcpt;
- Float_t ny = esdpy/mcpt;
-
- Float_t radius;
- radius = TMath::Abs(radiusMc);
-
- Double_t dxy = vxy - mcVtxXY;   // in cm
- Double_t dvx = vx - mcPrimV[0]; // in cm
- Double_t dvy = vy - mcPrimV[1]; // in cm
-
- Float_t mcDcaXY = (radius - TMath::Sqrt(dxy*dxy/100./100. + radius*radius + 2*radius*charge*(dvx*ny-dvy*nx)/100.)) ;  // in meters
-
- Double_t mcDca[2] = {mcDcaXY*100, vz};  // in cm
- Double_t residual[2] = {0, 0};
- Double_t pull[2] = {0, 0};
- Double_t error[2] ={TMath::Sqrt(covardz[0]), TMath::Sqrt(covardz[2])};
- for(Int_t i=0; i<2; i++){
-   residual[i] = dz[i] - mcDca[i]; // in centimeters       
-   if(error[i]!=0)pull[i] = residual[i]/error[i];   // unitless
- }
-
- Int_t iPart = -1;
- if(track->Charge()<0) iPart = 0;  // electron
- if(track->Charge()>0) iPart = 1;  // positron
- if(track->Charge()==0) {
-   printf("this is not an electron! Check HFEpid method");
-   return;
- }
- for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-   if(esdpt>fgkPtIntv[iPtBin] && esdpt<=fgkPtIntv[iPtBin+1]){
-     fHistHPDcaXYRes[iPart][iPtBin]->Fill(residual[0]*1.0e4);  
-     fHistHPDcaZRes[iPart][iPtBin]->Fill(residual[1]*1.0e4);   
-     fHistHPDcaXYPull[iPart][iPtBin]->Fill(pull[0]);  
-     fHistHPDcaZPull[iPart][iPtBin]->Fill(pull[1]); 
-     fHistHPDcaXY[iPart][iPtBin]->Fill(dz[0]*1.0e4); 
-     fHistHPDcaZ[iPart][iPtBin]->Fill(dz[1]*1.0e4);  
-
-   } // pt range
-
-   else
-     continue;
- }  // pt loop
-
- fHistHfePid[iPart][0]->Fill(esdpt);
- fHistHfePid[iPart][1]->Fill(mcpt);
-
-}
-
-
-//_______________________________________________________________________________________________
-void AliHFEdca::FillHistogramsHfeDataDca(const AliESDEvent * const esdEvent, const AliESDtrack * const track, const AliESDVertex * const vtxESDSkip)
-{
-// filling historgams track by track
-// obtaining reconstructed dca --------------------------------------------------------------
-
- Float_t esdpx = track->Px();
- Float_t esdpy = track->Py();
- Float_t esdpt = TMath::Sqrt(esdpx*esdpx+esdpy*esdpy);  
- Int_t charge = track->Charge();
-
-// obtaining errors of dca ------------------------------------------------------------------
- const AliESDVertex *primVtx = esdEvent->GetPrimaryVertex(); // UNUSED!     
- Double_t primV[3];
- primV[0] = primVtx->GetXv();
- primV[1] = primVtx->GetYv();
- primV[2] = primVtx->GetZv();
-
- Float_t magneticField = 0;  // initialized as 5kG
- magneticField = esdEvent->GetMagneticField();  // in kG
- Double_t beampiperadius=3.; 
-
- Double_t dz[2];   // error of dca in cm
- Double_t covardz[3];
-
- AliESDtrack ctrack(*track); // Propagate on copy track
- if(!ctrack.PropagateToDCA(vtxESDSkip,magneticField, beampiperadius, dz, covardz)) return; // protection
-
- Double_t pull[2] = {0, 0};
- Double_t error[2] ={TMath::Sqrt(covardz[0]), TMath::Sqrt(covardz[2])};
- for(Int_t i=0; i<2; i++){
-   if(error[i]!=0) pull[i] = dz[i]/error[i];   // unitless    
- }
-
- Int_t iPart = -1;
- if(charge<0) iPart = 0;  // electron
- if(charge>0) iPart = 1;  // positron
- if(charge==0) {
-   printf("this is not an electron! Check HFEpid method\n");
-   return;
- }
-
- for(Int_t iPtBin=0; iPtBin<kNPtBins; iPtBin++){
-   if(esdpt>fgkPtIntv[iPtBin] && esdpt<=fgkPtIntv[iPtBin+1]) {
-     fHistHPDataDcaXY[iPart][iPtBin]->Fill(dz[0]*1e4);
-     fHistHPDataDcaZ[iPart][iPtBin]->Fill(dz[1]*1e4);      
-     fHistHPDataDcaXYPull[iPart][iPtBin]->Fill(pull[0]);
-     fHistHPDataDcaZPull[iPart][iPtBin]->Fill(pull[1]);                      
-
-   }
-   else continue;
- }
-
- fHistDataHfePid[iPart]->Fill(esdpt);
-
-}
-
diff --git a/PWGHF/hfe/AliHFEdca.h b/PWGHF/hfe/AliHFEdca.h
deleted file mode 100644 (file)
index 86aea66..0000000
+++ /dev/null
@@ -1,195 +0,0 @@
-/**************************************************************************
-* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
-*                                                                        *
-* Author: The ALICE Off-line Project.                                    *
-* Contributors are mentioned in the code where appropriate.              *
-*                                                                        *
-* Permission to use, copy, modify and distribute this software and its   *
-* documentation strictly for non-commercial purposes is hereby granted   *
-* without fee, provided that the above copyright notice appears in all   *
-* copies and that both the copyright notice and this permission notice   *
-* appear in the supporting documentation. The authors make no claims     *
-* about the suitability of this software for any purpose. It is          *
-* provided "as is" without express or implied warranty.                  *
-**************************************************************************/
-//
-// Class for checking impact parameter (DCA) study 
-// + study DCA in rphi (xy) and z
-// + resolution and pull
-// + handle both MC and data 
-// + add plugin for primary vertex 
-//
-
-#ifndef ALIHFEDCA_H
-#define ALIHFEDCA_H
-
-#ifndef ROOT_TObject
-#include <TObject.h>
-#endif
-
-class TChain;
-class TTree;
-class TFile;
-
-class TString;
-class TList;
-
-class TObjArray;
-class AliStack;
-class AliMCEvent;
-class AliMCVertex;
-
-class AliESDEvent;
-class AliESDtrack;
-class AliESDVertex;
-
-class AliHFEdca : public TObject{
-
- public:  
-  enum{
-    kPDGelectron = 11,
-    kPDGmuon = 13,
-    kPDGpion = 211,
-    kPDGkaon = 321,
-    kPDGproton = 2212
-  };
-  enum{
-    kNParticles = 12,
-    kNPtBins = 50,   
-    kNDcaVar = 2, 
-    kNVertexVar = 3,  
-    kNPullVar = 2
-  };
-
-  AliHFEdca(); // default constructor
-  AliHFEdca(const AliHFEdca &ref); // copy constructor
-  AliHFEdca &operator=(const AliHFEdca &ref); // assignment operator
-  virtual ~AliHFEdca(); // destructor
-
-  void CreateHistogramsPull(TList *pullList);  
-  void CreateHistogramsResidual(TList *residualList);  
-  void CreateHistogramsDca(TList *dcaList);  
-
-  void CreateHistogramsKfDca(TList *kfDcaList);  
-
-  void CreateHistogramsDataDca(TList *dataDcaList);  
-  void CreateHistogramsDataPull(TList *dataPullList);  
-
-  void CreateHistogramsVertex(TList *vertexList);  
-  void CreateHistogramsDataVertex(TList *vertexList);  
-
-  void CreateHistogramsPid(TList *pidList);
-  void CreateHistogramsDataPid(TList *pidList);
-
-  void CreateHistogramsHfeDca(TList *hfeDcaList);
-  void CreateHistogramsHfeDataDca(TList *hfeDataDcaList);
-
-  
-  void InitAnalysis()const;  
-  void FillHistogramsDca(const AliESDEvent * const esdEvent,  const AliESDtrack *const track,  AliMCEvent *const mcEvent);
-  void FillHistogramsVtx(const AliESDEvent * const esdEvent,  const AliMCEvent *const mcEvent);
-  void FillHistogramsPid(const AliESDtrack *track, const  AliMCEvent * const mcEvent);
-
-  void FillHistogramsKfDca(const AliESDEvent * const esdEvent,  const AliESDtrack *const track,  const AliMCEvent *const mcEvent);
-
-  void FillHistogramsDataDca(const AliESDEvent * const esdEvent,  const AliESDtrack * const track, const AliESDVertex * const vtxESDSkip);
-  void FillHistogramsDataVtx(const AliESDEvent * const esdEvent);
-  void FillHistogramsDataPid(const AliESDtrack * const track);
-
-  void FillHistogramsHfeDca(const AliESDEvent *const esdEvent,  const AliESDtrack * const track,  const AliMCEvent * const mcEvent);
-  void FillHistogramsHfeDataDca(const AliESDEvent * const esdEvent, const AliESDtrack * const track, const AliESDVertex * const vtxESDSkip);
-
-
-  void ApplyExtraCuts(const AliESDEvent * const esdEvent, Int_t nMinPrimVtxContributor);
-
-  void PostAnalysis() const;
-
-  Int_t GetCombinedPid(const AliESDtrack * const track);
-
- private:   
-
-
-  static const Char_t* fgkParticles[kNParticles];  // particle names
-  static const Int_t fgkPdgParticle[kNParticles-2]; // identified particle's name
-  static const Int_t fgkColorPart[kNParticles]; // colors for particles
-
-  static const Float_t fgkPtIntv[kNPtBins+1];  // pt intervals
-
-  static const Char_t* fgkDcaVar[kNDcaVar];  // dca variables
-  static const Char_t* fgkDcaVarTitle[kNDcaVar]; // titles for dca variables
-
-  static const Char_t* fgkVertexVar[kNVertexVar];  // dca variables
-  static const Char_t* fgkVertexVarTitle[kNVertexVar]; // titles for dca variables
-
-  static const Char_t* fgkResDcaVar[kNDcaVar];  // dca variables
-  static const Char_t* fgkResDcaVarTitle[kNDcaVar]; // titles for dca variables
-
-  static const Char_t* fgkPullDcaVar[kNPullVar];  // pull variables
-  static const Char_t* fgkPullDcaVarTitle[kNPullVar]; // titles for pull variables
-  static const Char_t* fgkPullDataDcaVarTitle[kNPullVar]; // titles for pull variables
-
-  TH1F* fHistDcaXYRes[kNParticles][kNPtBins];  //! residuals in XY
-  TH1F* fHistDcaZRes[kNParticles][kNPtBins];   //! residuals in Z
-
-  TH1F* fHistDcaXYPull[kNParticles][kNPtBins]; //! pulls XY
-  TH1F* fHistDcaZPull[kNParticles][kNPtBins];  //! pulls Z
-
-  TH1F* fHistDcaXY[kNParticles][kNPtBins]; //! dca XY
-  TH1F* fHistDcaZ[kNParticles][kNPtBins];  //! dca Z
-
-  TH1F* fHistEPDcaXYRes[kNParticles-2][kNPtBins];  //! residuals in XY with esd pid
-  TH1F* fHistEPDcaZRes[kNParticles-2][kNPtBins];   //! residuals in Z with esd pid
-
-  TH1F* fHistEPDcaXYPull[kNParticles-2][kNPtBins]; //! pulls XY with esd pid
-  TH1F* fHistEPDcaZPull[kNParticles-2][kNPtBins];  //! pulls Z with esd pid
-
-  TH1F* fHistEPDcaXY[kNParticles-2][kNPtBins]; //! dca XY with esd pid
-  TH1F* fHistEPDcaZ[kNParticles-2][kNPtBins];  //! dca Z with esd pid
-
-  TH1F* fHistKFDcaXY[kNParticles][kNPtBins]; //! KF dca XY
-  TH1F* fHistKFDcaZ[kNParticles][kNPtBins];  //! KF dca Z
-  
-  TH1F* fHistDataDcaXY[kNParticles][kNPtBins]; //! data dca XY
-  TH1F* fHistDataDcaZ[kNParticles][kNPtBins];  //! data dca Z
-  TH1F* fHistDataWoDcaXY[kNParticles][kNPtBins]; //! data dca XY w/o current trk
-  TH1F* fHistDataWoDcaZ[kNParticles][kNPtBins];  //! data dca Z w/o current trk
-
-  TH1F* fHistDataDcaXYPull[kNParticles][kNPtBins]; //! data pull dca XY
-  TH1F* fHistDataDcaZPull[kNParticles][kNPtBins];  //! data pull dca Z 
-  TH1F* fHistDataWoDcaXYPull[kNParticles][kNPtBins]; //! data pull dca XY w/o current trk
-  TH1F* fHistDataWoDcaZPull[kNParticles][kNPtBins];  //! data pull dca Z  w/o current trk
-
-  TH1F* fHistMCvertex[kNVertexVar];    //! vertex MC
-  TH1F* fHistESDvertex[kNVertexVar];   //! vertex ESD
-  TH1F* fHistDatavertex[kNVertexVar];  //! vertex Data
-  
-  TH1F* fHistMcPid[kNParticles];      //! MC pid pt spectra
-  TH1F* fHistEsdPid[kNParticles];     //! ESD pid pt spectra
-
-  TH1F *fHistDataEsdPid[kNParticles];    //! Data ESD pid
-
-  // HFE pid part
-  // MC
-  TH1F* fHistHPDcaXYRes[2][kNPtBins];  //! residuals in XY
-  TH1F* fHistHPDcaZRes[2][kNPtBins];   //! residuals in Z
-  TH1F* fHistHPDcaXYPull[2][kNPtBins]; //! pulls XY
-  TH1F* fHistHPDcaZPull[2][kNPtBins];  //! pulls Z
-  TH1F* fHistHPDcaXY[2][kNPtBins];     //! dca XY
-  TH1F* fHistHPDcaZ[2][kNPtBins];      //! dca Z
-
-  TH1F* fHistHfePid[2][2];             // ! HFE pid pt spectra only for electrons
-
-  // Data
-  TH1F* fHistHPDataDcaXY[2][kNPtBins];     //! data dca XY with HFE pid
-  TH1F* fHistHPDataDcaZ[2][kNPtBins];      //! data dca Z with HFE pid
-  TH1F* fHistHPDataDcaXYPull[2][kNPtBins]; //! data pull dca XY
-  TH1F* fHistHPDataDcaZPull[2][kNPtBins];  //! data pull dca Z 
-
-  TH1F *fHistDataHfePid[2];            //! Data HFE pid
-
-  TH1I* fStat;                         //! counting diff of dca calculated from HF particle and ESD
-  ClassDef(AliHFEdca, 1);
-};
-
-#endif
index fe1b682..194441c 100644 (file)
@@ -261,7 +261,7 @@ void AliHFEdebugTreeTask::UserExec(Option_t *){
                     << "pdg="                 << pdg
                     << "ProductionVertex="    << productionVertex
                     << "motherPdg="           << motherPdg
-                  << "source="              << source
+                    << "source="              << source
                     << "\n";
     }
   }
@@ -282,7 +282,7 @@ void AliHFEdebugTreeTask::UserExec(Option_t *){
     Double_t nSigmaTPC = pid->NumberOfSigmasTPC(&copyTrack, AliPID::kElectron);
     //if(TMath::Abs(nSigmaTOF) > 5) continue;
     // we are not interested in tracks which are more than 5 sigma away from the electron hypothesis in either TOF or TPC
-    Double_t tPCdEdx = track->GetTPCsignal();
+    Double_t tPCdEdx = copyTrack.GetTPCsignal();
     // Signal, source and MCPID
     Bool_t signal = kTRUE;
     source = 5;
@@ -357,6 +357,7 @@ void AliHFEdebugTreeTask::UserExec(Option_t *){
       unique=mctrackt->GetUniqueID();
     
       AliMCParticle *mctrackmother = NULL;
+      AliMCParticle *mctrackmother2 = NULL;
 
       if(!(mArr<0)){
     if(mesonID>=AliHFEmcQA::kGammaPi0) {  // conversion electron, be careful with the enum odering
@@ -372,8 +373,15 @@ void AliHFEdebugTreeTask::UserExec(Option_t *){
 
           mctrackt = mctrackmother->Particle();
           if(mctrackt){
-        mesonunique = mctrackt->GetUniqueID();
+            mesonunique = mctrackt->GetUniqueID();
           }
+
+        Int_t glabel2=TMath::Abs(mctrackmother->GetMother()); // gamma's mother's mother
+        if((mctrackmother2 = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(glabel2)))){
+            mesonMomPdg=mctrackmother2->PdgCode();
+            mesonMomPt=mctrackmother2->Pt();
+        }
+
           if(glabel>fMCEvent->GetNumberOfPrimaries()) {
         bgcategory = 2.;
         glabel=TMath::Abs(mctrackmother->GetMother()); // gamma's mother's mother
@@ -467,9 +475,13 @@ void AliHFEdebugTreeTask::UserExec(Option_t *){
     UChar_t nclustersTRD = track->GetTRDncls();
     UChar_t ntrackletsTRDPID = track->GetTRDntrackletsPID();
     // ITS and TRD acceptance maps
-    UChar_t hasClusterITS[6], hasTrackletTRD[6];
+    UChar_t hasClusterITS[6], statusITS[5], hasTrackletTRD[6];
     UChar_t itsPixel = track->GetITSClusterMap();
-    for(Int_t icl = 0; icl < 6; icl++) hasClusterITS[icl] = TESTBIT(itsPixel, icl) ? 1 : 0;
+    for(Int_t icl = 0; icl < 6; icl++){ 
+      hasClusterITS[icl] = TESTBIT(itsPixel, icl) ? 1 : 0;
+      if(CheckITSstatus(track, icl)) statusITS[icl] = 1;
+      else statusITS[icl] = 0;
+    }
     Double_t trddEdxSum[6];
     for(Int_t a=0;a<6;a++) { trddEdxSum[a]= 0.;}
     for(Int_t itl = 0; itl < 6; itl++){
@@ -541,31 +553,37 @@ void AliHFEdebugTreeTask::UserExec(Option_t *){
                   << "nclustersITS="        << nclustersITS
                   << "nclusters="           << nclustersTRD
                   << "chi2matching="        << chi2matching
-      << "chi2PerClusterITS="   << chi2PerClusterITS
+                  << "chi2PerClusterITS="   << chi2PerClusterITS
                   << "its0="                << hasClusterITS[0]
                   << "its1="                << hasClusterITS[1]
                   << "its2="                << hasClusterITS[2]
                   << "its3="                << hasClusterITS[3]
                   << "its4="                << hasClusterITS[4]
                   << "its5="                << hasClusterITS[5]
+                  << "statusITS0="          << statusITS[0]
+                  << "statusITS1="          << statusITS[1]
+                  << "statusITS2="          << statusITS[2]
+                  << "statusITS3="          << statusITS[3]
+                  << "statusITS4="          << statusITS[4]
+                  << "statusITS5="          << statusITS[5]
                   << "trd0="                << hasTrackletTRD[0]
                   << "trd1="                << hasTrackletTRD[1]
                   << "trd2="                << hasTrackletTRD[2]
                   << "trd3="                << hasTrackletTRD[3]
                   << "trd4="                << hasTrackletTRD[4]
                   << "trd5="                << hasTrackletTRD[5]
-            << "TRDdEdxl0="           << trddEdxSum[0]
-            << "TRDdEdxl1="           << trddEdxSum[1]
-            << "TRDdEdxl2="           << trddEdxSum[2]
-            << "TRDdEdxl3="           << trddEdxSum[3]
-            << "TRDdEdxl4="           << trddEdxSum[4]
-            << "TRDdEdxl5="           << trddEdxSum[5]
+                  << "TRDdEdxl0="           << trddEdxSum[0]
+                  << "TRDdEdxl1="           << trddEdxSum[1]
+                  << "TRDdEdxl2="           << trddEdxSum[2]
+                  << "TRDdEdxl3="           << trddEdxSum[3]
+                  << "TRDdEdxl4="           << trddEdxSum[4]
+                  << "TRDdEdxl5="           << trddEdxSum[5]
                   << "TOFsigmaEl="          << nSigmaTOF
                   << "TPCsigmaEl="          << nSigmaTPC
                   << "TPCdEdx="             << tPCdEdx
                   << "TRDlikeEl="           << likeEleTRD
                   << "TRDlikeEln="          << likeEleTRDn
-            << "trdtruncmean1="       << trdtruncmean1
+                  << "trdtruncmean1="       << trdtruncmean1
                   << "trdtruncmean2="       << trdtruncmean2
                   << "dcaR="                << b[0]
                   << "dcaZ="                << b[1]
@@ -580,18 +598,18 @@ void AliHFEdebugTreeTask::UserExec(Option_t *){
                   << "vx="                  << vtx[0]
                   << "vy="                  << vtx[1]
                   << "vz="                  << vtx[2]
-            << "tofdx="                << tofdx
-            << "tofdz="                << tofdz
-            << "ncontrib="            << ncontrib
-            << "mesonID="             << mesonID
-            << "eR="                  << eR
-            << "mesonR="              << mesonR
-            << "eZ="                  << eZ
-            << "mesonZ="              << mesonZ
-            << "unique="              << unique
-            << "mesonunique="         << mesonunique
-            << "bgcategory="          << bgcategory
-            << "mesonpt="             << mesonPt
+                  << "tofdx="                << tofdx
+                  << "tofdz="                << tofdz
+                  << "ncontrib="            << ncontrib
+                  << "mesonID="             << mesonID
+                  << "eR="                  << eR
+                  << "mesonR="              << mesonR
+                  << "eZ="                  << eZ
+                  << "mesonZ="              << mesonZ
+                  << "unique="              << unique
+                  << "mesonunique="         << mesonunique
+                  << "bgcategory="          << bgcategory
+                  << "mesonpt="             << mesonPt
                   << "mesonMomPdg="         << mesonMomPdg
                   << "mesonGMomPdg="         << mesonGMomPdg
                   << "mesonGGMomPdg="         << mesonGGMomPdg
@@ -761,3 +779,23 @@ Int_t AliHFEdebugTreeTask::GetElecSourceMC(TParticle * const mcpart)
   }
   return origin;
 }
+
+//______________________________________________________
+Bool_t AliHFEdebugTreeTask::CheckITSstatus( const AliESDtrack * const esdtrack, Int_t layer) const {
+  //
+  // Check whether ITS area is dead
+  //
+  Int_t itsStatus = 0;
+  Int_t det;
+  Float_t xloc, zloc;
+  esdtrack->GetITSModuleIndexInfo(layer, det, itsStatus, xloc, zloc);
+  Bool_t status;
+  switch(itsStatus){
+    case 2: status = kFALSE; break;
+    case 3: status = kFALSE; break;
+    case 7: status = kFALSE; break;
+    default: status = kTRUE;
+  }
+  return status;
+}
+
index 31f49e7..d3cd124 100644 (file)
@@ -52,6 +52,7 @@ class AliHFEdebugTreeTask : public AliAnalysisTaskSE{
     AliHFEdebugTreeTask &operator=(const AliHFEdebugTreeTask &);
 
     AliTrackReference *FindTrackReference(AliMCParticle *track, Float_t minRadius, Float_t maxRadius, Int_t detectorID);
+    Bool_t CheckITSstatus( const AliESDtrack * const esdtrack, Int_t layer) const;
     
     AliHFEcuts *fTrackCuts;           // Track
     AliHFEsignalCuts *fSignalCuts;    // Signal Cuts
diff --git a/PWGHF/hfe/AliHFEdisplacedElectrons.cxx b/PWGHF/hfe/AliHFEdisplacedElectrons.cxx
deleted file mode 100644 (file)
index 7875875..0000000
+++ /dev/null
@@ -1,956 +0,0 @@
-/*************************************************************************
-* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
-*                                                                        *
-* Author: The ALICE Off-line Project.                                    *
-* Contributors are mentioned in the code where appropriate.              *
-*                                                                        *
-* Permission to use, copy, modify and distribute this software and its   *
-* documentation strictly for non-commercial purposes is hereby granted   *
-* without fee, provided that the above copyright notice appears in all   *
-* copies and that both the copyright notice and this permission notice   *
-* appear in the supporting documentation. The authors make no claims     *
-* about the suitability of this software for any purpose. It is          *
-* provided "as is" without express or implied warranty.                  *
-**************************************************************************/
-//
-// Class for electrons from beauty study
-// Counting electrons from beauty
-// by DCA cuts, background subtraction 
-//
-// Authors:
-//   Hongyan Yang <hongyan@physi.uni-heidelberg.de>
-//   Carlo Bombonati <Carlo.Bombonati@cern.ch>
-//
-
-#include "TMath.h"
-#include "TList.h"
-#include "AliLog.h"
-
-#include <TParticle.h>
-#include <TDatabasePDG.h>
-#include "THnSparse.h"
-
-#include "AliMCEvent.h"
-#include "AliMCVertex.h"
-#include "AliMCParticle.h"
-#include "AliStack.h" 
-
-#include "AliESDEvent.h"
-#include "AliESDtrack.h"
-
-#include "AliKFParticle.h"
-#include "AliKFVertex.h"
-
-#include "AliVertexerTracks.h"
-
-
-#include "AliHFEdisplacedElectrons.h"
-
-ClassImp(AliHFEdisplacedElectrons)
-
-//__________________________________________________________
-const Float_t AliHFEdisplacedElectrons::fgkDcaMinPtIntv[13] = {
-  // 
-  // define DCA low limits for single electrons cut in each Pt bin 
-  // preliminary numbers 
-  // these numbers should be replaced by the best numbers determined by 
-  // cut efficiency study: signal/background  (not used right now)
-  //
-  450, // 0.0 - 0.5
-  450, // 0.5 - 1.0
-  450, // 1.0 - 1.5
-  500, // 1.5 - 2.0
-  400, // 2.0 - 2.5
-  300, // 2.5 - 3.0
-  300, // 3.0 - 4.0
-  300, // 4.0 - 5.0
-  200, // 5.0 - 7.0
-  150, // 7.0 - 9.0
-  150, // 9.0 - 12.0
-  100, //12.0 - 16.0
-  50}; //16.0 - 20.0
-//__________________________________________________________
-const Float_t AliHFEdisplacedElectrons::fgkPtIntv[14] = {
-  //
-  // define pT bins for spectra of single electrons 
-  //
-  0.0,0.5,1.0,1.5,2.0,2.5,3.0,4.0,5.0,7.0,9.0,12.0,16.0,20.0};
-
-//__________________________________________________________
-const Char_t *AliHFEdisplacedElectrons::fgkKineVar[3] = {
-  "y", "phi", "pt"};
-
-//__________________________________________________________
-const Char_t *AliHFEdisplacedElectrons::fgkKineVarTitle[3] ={
-  "rapidity;y;dN/dy",   "azimuthal;#phi;dN/d#phi",   "transverse momentum;p_{T};dN/dp_{T}", 
-};
-
-//__________________________________________________________
-AliHFEdisplacedElectrons::AliHFEdisplacedElectrons():
-  fDeDebugLevel(0)
-  , fNclustersITS(0)
-  , fMinNprimVtxContributor(1)
-  , fTHnSparseDcaMcEleInfo(NULL)
-  , fTHnSparseDcaEsdEleInfo(NULL)
-  , fTHnSparseDcaDataEleInfo(NULL)
-  , fDeOutputList(0x0)
-{
-  //
-  // default constructor
-  //
-
-}
-
-//__________________________________________________________
-AliHFEdisplacedElectrons::AliHFEdisplacedElectrons(const AliHFEdisplacedElectrons &ref):
-  TObject(ref)
-  , fDeDebugLevel(ref.fDeDebugLevel)
-  , fNclustersITS(ref.fNclustersITS)
-  , fMinNprimVtxContributor(ref.fMinNprimVtxContributor)
-  , fTHnSparseDcaMcEleInfo(ref.fTHnSparseDcaMcEleInfo)
-  , fTHnSparseDcaEsdEleInfo(ref.fTHnSparseDcaEsdEleInfo)
-  , fTHnSparseDcaDataEleInfo(ref.fTHnSparseDcaDataEleInfo)
-  , fDeOutputList(ref.fDeOutputList)
-  
-{
-  //
-  // copy constructor
-  //
-}
-
-
-//__________________________________________________________
-AliHFEdisplacedElectrons&AliHFEdisplacedElectrons::operator=(const AliHFEdisplacedElectrons &ref)
-{
-  //
-  // Assignment operator
-  //
-
-  if(this == &ref) return *this;
-  AliHFEdisplacedElectrons::operator=(ref);
-
-  fDeDebugLevel = ref.fDeDebugLevel;
-  fNclustersITS = ref.fNclustersITS;
-  fMinNprimVtxContributor = ref.fMinNprimVtxContributor;
-  fTHnSparseDcaMcEleInfo = ref.fTHnSparseDcaMcEleInfo;
-  fTHnSparseDcaEsdEleInfo = ref.fTHnSparseDcaEsdEleInfo;
-  fTHnSparseDcaDataEleInfo = ref.fTHnSparseDcaDataEleInfo;
-  fDeOutputList = ref.fDeOutputList;
-
-  return *this;
-}
-
-//__________________________________________________________
-AliHFEdisplacedElectrons::~AliHFEdisplacedElectrons()
-{
-  //
-  // default constructor
-  //
-
-  if(fTHnSparseDcaMcEleInfo) 
-    delete fTHnSparseDcaMcEleInfo;
-  if(fTHnSparseDcaEsdEleInfo) 
-    delete fTHnSparseDcaEsdEleInfo;
-  if(fTHnSparseDcaDataEleInfo) 
-    delete fTHnSparseDcaDataEleInfo;
-    
-  if(fDeOutputList){
-    fDeOutputList->Clear();
-    delete fDeOutputList;
-    
-  }
-
-  Printf("analysis done\n");
-}
-
-//__________________________________________________________
-void AliHFEdisplacedElectrons::InitAnalysis(){
-  //
-  // init analysis (no intialization yet)
-  //
-  
-
-  Printf("initialize analysis\n");
-
-}
-
-
-//__________________________________________________________
-void AliHFEdisplacedElectrons::CreateOutputs(TList* const displacedList){
-
-  //
-  //  create output fDeOutputList
-  //
-
-  // THnSparseF
-  // 8+? interested electron sources: others, photon conv, direct photon,  pi0, eta, b, b->c, c + pion or missid, and missid pion
-  // 41 possible DCA cuts XY: 
-  // 13 pT bins
-  // 10 rapidity bins
-  // 10 azimuthal angle phi bins
-
-
-  if(!displacedList) return;
-
-  fDeOutputList = displacedList;
-  fDeOutputList -> SetName("displacedElectrons");
-
-  // electron source 
-  Int_t nBinsEleSource = 10;
-  Double_t minEleSource = -1.5; 
-  Double_t maxEleSource = 8.5;  
-  Double_t *binLimEleSource = new Double_t[nBinsEleSource+1];
-  for(Int_t i=0; i<=nBinsEleSource; i++)
-    binLimEleSource[i] = minEleSource + i*(maxEleSource-minEleSource)/nBinsEleSource;
-
-  // dca bins:  XY 
-  Int_t nBinsDcaXY = kNDcaMin-1;  // 41 bins
-  Double_t minDcaXY = -20.5; 
-  Double_t maxDcaXY = 20.5; 
-  Double_t dcaXYBinWidth = (maxDcaXY-minDcaXY)/nBinsDcaXY;
-  Double_t *binLimDcaXY = new Double_t[nBinsDcaXY+1];
-  for(Int_t i=0; i<=nBinsDcaXY; i++)
-    binLimDcaXY[i] = minDcaXY + i*dcaXYBinWidth;
-
-
-  // dca bins:  Z
-  Int_t nBinsDcaZ = kNDcaMin/2;  // 21 bins
-  Double_t minDcaZ = -10.5; 
-  Double_t maxDcaZ = 10.5; 
-  Double_t dcaZBinWidth = (maxDcaZ-minDcaZ)/nBinsDcaZ;
-  Double_t *binLimDcaZ = new Double_t[nBinsDcaZ+1];
-  for(Int_t i=0; i<=nBinsDcaZ; i++)
-    binLimDcaZ[i] = minDcaZ + i*dcaZBinWidth;
-  
- // pt bins
-  Int_t nBinsPt = kNPtIntv-1;
-  Double_t *binLimPt = new Double_t[nBinsPt+1];
-  for(Int_t i=0; i<=nBinsPt; i++)
-    binLimPt[i] = fgkPtIntv[i];  // variable bins
-
-  // rapidity bins
-  Int_t nBinsRap = 10;
-  Double_t minRap = -1.0; 
-  Double_t maxRap = 1.0;
-  Double_t *binLimRap = new Double_t[nBinsRap+1];
-  for(Int_t i=0; i<=nBinsRap; i++)
-    binLimRap[i] = minRap + i*(maxRap-minRap)/nBinsRap;
-
-  // azumuthal phi angle
-  Int_t nBinsPhi = 10;
-  Double_t minPhi = 0; 
-  Double_t maxPhi = 2*TMath::Pi();
-  Double_t *binLimPhi = new Double_t[nBinsPhi+1];
-  for(Int_t i=0; i<=nBinsPhi; i++)
-    binLimPhi[i] = minPhi + i*(maxPhi-minPhi)/nBinsPhi;
-
-  // production radii
-  Int_t nBinsR = 30;
-  Double_t minR = 0; 
-  Double_t maxR = 15;
-  Double_t *binLimR = new Double_t[nBinsR+1];
-  for(Int_t i=0; i<=nBinsR; i++)
-    binLimR[i] = minR + i*(maxR-minR)/nBinsR;
-
-  // status
-  Int_t nBinsStat = 11;
-  Double_t minStat = 0; 
-  Double_t maxStat = 11;
-  Double_t *binLimStat = new Double_t[nBinsStat+1];
-  for(Int_t i=0; i<=nBinsStat; i++)
-    binLimStat[i] = minStat + i*(maxStat-minStat)/nBinsStat;
-
-  fTHnSparseDcaMcEleInfo = 0x0;
-  fTHnSparseDcaEsdEleInfo = 0x0;
-  fTHnSparseDcaDataEleInfo = 0x0;
-
-  // for MC only: MC electron ID
-  const Int_t nVarMc = 8;
-  Int_t iBinMc[nVarMc] = {nBinsEleSource, nBinsDcaXY, nBinsDcaZ, nBinsPt, nBinsRap, nBinsPhi, nBinsR, nBinsStat};
-  
-  fTHnSparseDcaMcEleInfo = new THnSparseF("dcaMcElectronInfo", 
-                                          "MC electrons;electron source ID;mc dcaXY [50 #mum];mc dcaZ [100 #mum];mc pT [GeV/c];mc y [rapidity];mc #phi [rad];mc R [cm];Status Code",   
-                                          nVarMc, iBinMc);
-
-  fTHnSparseDcaMcEleInfo->SetBinEdges(0, binLimEleSource); // electron source
-  fTHnSparseDcaMcEleInfo->SetBinEdges(1, binLimDcaXY);  // dca xy cut
-  fTHnSparseDcaMcEleInfo->SetBinEdges(2, binLimDcaZ);  // dca z cut
-  fTHnSparseDcaMcEleInfo->SetBinEdges(3, binLimPt);   // pt
-  fTHnSparseDcaMcEleInfo->SetBinEdges(4, binLimRap);  // rapidity
-  fTHnSparseDcaMcEleInfo->SetBinEdges(5, binLimPhi);  // phi
-  fTHnSparseDcaMcEleInfo->SetBinEdges(6, binLimR);
-  fTHnSparseDcaMcEleInfo->SetBinEdges(7, binLimStat);
-  fTHnSparseDcaMcEleInfo->Sumw2();  
-
-  // for ESD with MC: HFE pid and MC pid
-  const Int_t nVarEsd = 9;
-  Int_t iBin[nVarEsd] = {nBinsEleSource,nBinsDcaXY, nBinsDcaZ, nBinsDcaXY, nBinsPt, nBinsRap, nBinsPhi, nBinsR, nBinsStat};
-  
-  fTHnSparseDcaEsdEleInfo 
-    = new THnSparseF("dcaEsdElectronInfo", 
-                    "ESD electrons;electron source ID;esd dcaXY [50 #mum];esd dcaZ [100 #mum];esd dcaXY KF [50 #mum];pT [GeV/c];y [rapidity];#phi [rad];R [cm];Status Code",           
-                    nVarEsd, iBin);
-
-  fTHnSparseDcaEsdEleInfo->SetBinEdges(0, binLimEleSource); // electron source
-  fTHnSparseDcaEsdEleInfo->SetBinEdges(1, binLimDcaXY);  // dca xy without current track
-  fTHnSparseDcaEsdEleInfo->SetBinEdges(2, binLimDcaZ);  // dca z without current track
-  fTHnSparseDcaEsdEleInfo->SetBinEdges(3, binLimDcaXY);  // dca xy kf without current track
-  fTHnSparseDcaEsdEleInfo->SetBinEdges(4, binLimPt);   // pt esd
-  fTHnSparseDcaEsdEleInfo->SetBinEdges(5, binLimRap);  // rapidity esd
-  fTHnSparseDcaEsdEleInfo->SetBinEdges(6, binLimPhi);  // phi esd
-  fTHnSparseDcaEsdEleInfo->SetBinEdges(7, binLimR);
-  fTHnSparseDcaEsdEleInfo->SetBinEdges(8, binLimStat);
-  fTHnSparseDcaEsdEleInfo->Sumw2();
-  
-
-  // for ESD data: HFE pid
-  const Int_t nVarData = 6;
-  Int_t iBinData[nVarData] = {nBinsDcaXY, nBinsDcaZ, nBinsDcaXY, nBinsPt, nBinsRap, nBinsPhi};  
-  
-  fTHnSparseDcaDataEleInfo 
-    = new THnSparseF("dcaDataElectronInfo", 
-                    "Data electrons;dcaXY [50 #mum];dcaZ [100 #mum];dcaXYkf [50 #mum];pT [GeV/c];y [rapidity];#phi [rad];",
-                    nVarData, iBinData);    
-  fTHnSparseDcaDataEleInfo->SetBinEdges(0, binLimDcaXY);  // dca xy cut w/o
-  fTHnSparseDcaDataEleInfo->SetBinEdges(1, binLimDcaZ);  // dca z cut w/o
-  fTHnSparseDcaDataEleInfo->SetBinEdges(2, binLimDcaXY);  // dca xy kf cut 
-  fTHnSparseDcaDataEleInfo->SetBinEdges(3, binLimPt);   // pt
-  fTHnSparseDcaDataEleInfo->SetBinEdges(4, binLimRap);  // rapidity
-  fTHnSparseDcaDataEleInfo->SetBinEdges(5, binLimPhi);  // phi
-  fTHnSparseDcaDataEleInfo->Sumw2();
-
-  fDeOutputList -> AddAt(fTHnSparseDcaMcEleInfo, kMcElectron);
-  fDeOutputList -> AddAt(fTHnSparseDcaEsdEleInfo, kEsdElectron);
-  fDeOutputList -> AddAt(fTHnSparseDcaDataEleInfo, kDataElectron);
-  
-  AliInfo("THnSparse histograms are created\n");
-  fDeOutputList->Print();
-
-}
-
-
-//__________________________________________________________
-void AliHFEdisplacedElectrons::FillMcOutput(const AliESDEvent *const fESD, AliMCEvent* const fMC, const AliMCParticle* const mctrack)
-{
-
-  // fill output
-  //0. after mc event cut
-  //1. after checking stack, mcpart etc are valid
-  //2. after PID
-  //3. after event and track selection 
-
-  AliStack *stack = fMC->Stack();
-  TParticle *part = mctrack->Particle();
-
-  // obtain impact parameters in xy and z
-  AliMCVertex *mcPrimVtx = (AliMCVertex *)fMC->GetPrimaryVertex();      
-  Double_t mcPrimV[3];
-  mcPrimV[0] = mcPrimVtx->GetX();
-  mcPrimV[1] = mcPrimVtx->GetY();
-  mcPrimV[2] = mcPrimVtx->GetZ();
-
-  Double_t mcVtxXY = TMath::Abs(mcPrimV[0]*mcPrimV[0] + mcPrimV[1]*mcPrimV[1]);
-
-  Float_t vx = part->Vx();  // in cm
-  Float_t vy = part->Vy();  // in cm
-  Float_t vz = part->Vz();   // in cm
-  
-  Float_t vxy = TMath::Sqrt(vx*vx+vy*vy);
-  
-  Float_t mcpx = part->Px();
-  Float_t mcpy = part->Py();
-  Float_t mcpt = TMath::Sqrt(mcpx*mcpx+mcpy*mcpy);
-  Float_t mceta = part->Eta();
-  Float_t mcphi = part->Phi();
-
-  // begin new stuff
-  Double_t mcR = part->R();
-  Int_t mcStatus = part->GetStatusCode();
-  // end new staff
-
-  Int_t pdg = part->GetPdgCode();
-  
-  Int_t charge = 1;
-  if(pdg==kPDGelectron || pdg==-kPDGpion) charge = -1;  
-  
-  // calculate mcDca ------------------------------------------------------------------ 
-  const Float_t conv[2] = {1.783/1.6, 2.99792458};
-  Float_t magneticField = 0;  // initialized as 5kG
-  magneticField = fESD->GetMagneticField();  // in kG
-  Float_t radiusMc = mcpt/(TMath::Abs(magneticField)/10.)*conv[0]*conv[1]; // pt in GeV/c, magnetic field in Tesla, radius in meter
-  
-  Float_t radius;
-  radius = TMath::Abs(radiusMc);
-  Float_t nx = mcpx/mcpt;
-  Float_t ny = mcpy/mcpt;
-  Double_t dxy = vxy - mcVtxXY;   // in cm
-  Double_t dvx = vx - mcPrimV[0]; // in cm
-  Double_t dvy = vy - mcPrimV[1]; // in cm
-  Float_t mcDcaXYm = (radius - TMath::Sqrt(dxy*dxy/100./100. + radius*radius + 2*radius*charge*(dvx*ny-dvy*nx)/100.)) ;  // in meters
-  Double_t mcDca[2] = {mcDcaXYm*100, vz};  // in cm
-  Double_t mcDcaXY = mcDca[0]*1.0e4;  // conv dca in cm to dca in micron 
-  Double_t mcDcaZ = mcDca[1]*1.0e4;
-    
-  const Int_t nvarMC=8;
-  Double_t var[nvarMC];
-  var[0] = -1;
-  
-  if(TMath::Abs(pdg)==kPDGelectron) {
-
-    Int_t eleLabel = mctrack->GetLabel();
-    Int_t sourcePdg = ElectronFromSource(stack, eleLabel);     
-    
-    if(sourcePdg==kPDGgamma){ // check direct photon or not 
-      if(ElePhotonDirect(stack, eleLabel)!=-1) 
-       var[0] = kEleDirectPhotonConv;    
-      else     
-       var[0] = kElePhotonConv;     
-      if(fDeDebugLevel>=10) 
-       printf("photonconv=====this electron %d is from %d, source id=%.1f\n", eleLabel, sourcePdg, var[0]);   
-    }   // photon or direct photon -> e
-    
-    if(sourcePdg==kPDGpi0){      
-      var[0] = kElePi0;   
-      if(fDeDebugLevel>=10) printf("pi0======this electron %d is from %d, source id=%.1f\n", eleLabel, sourcePdg, var[0]);    
-    } 
-    
-    if(sourcePdg==kPDGeta){ 
-      var[0] = kEleEta;     
-      if(fDeDebugLevel>=10) 
-       printf("eta=====this electron %d is from %d, source id=%.1f\n", eleLabel, sourcePdg, var[0]);    
-    }   // from eta -> e
-    
-    if(TMath::Abs(sourcePdg%10000)/100==kPDGbeauty ||    // for special intermediate meson states: like 100553       
-       TMath::Abs(sourcePdg)/1000==kPDGbeauty ||      
-       TMath::Abs(sourcePdg)/100==kPDGbeauty ||     
-       TMath::Abs(sourcePdg)==kPDGbeauty){     
-      var[0]=kEleB;       
-      if(fDeDebugLevel>=10) 
-       printf("beauty======electron %d is from %d with id %.1f\n", eleLabel, ElectronFromSource(stack, eleLabel), var[0]);   
-    } // direct beauty  -> e      
-    if(TMath::Abs(sourcePdg%10000)/100==kPDGcharm ||    // for special intermediate meson states: like 1004**      
-       TMath::Abs(sourcePdg)/1000==kPDGcharm ||       
-       TMath::Abs(sourcePdg)/100==kPDGcharm ||        
-       TMath::Abs(sourcePdg)==kPDGcharm){           
-      // two cases: 
-      //            electron from b->c->e     
-      //            electron from c->e     
-      if(ElectronFromCharm(stack, eleLabel)!=-1){
-       var[0] = ElectronFromCharm(stack, eleLabel);
-       if(fDeDebugLevel>=10)
-         printf("charm----->electron %d has mother %d is from %.1f\n", eleLabel, ElectronFromSource(stack, eleLabel), var[0]);
-      } 
-    }  // charm electrons: b->c->e or c->e
-    
-    if(fDeDebugLevel>=10) printf("others----->electron %d has mother %d is from %.1f\n", eleLabel, ElectronFromSource(stack, eleLabel), var[0]);
-  } // electron source endif 
-  
-  else
-    if(TMath::Abs(pdg)==kPDGpion)
-      var[0] = kPion;
-  
-  if(TMath::Abs(mcDcaXY)<1000) var[1] = Int_t(mcDcaXY)/50;   // larger than 1mm should go to the last bin
-  else
-    var[1] = ((mcDcaXY>0)?1:-1)*20;
-  
-  if(TMath::Abs(mcDcaZ)<1000) var[2] = Int_t(mcDcaZ)/100;
-  else
-    var[2] = ((mcDcaZ>0)?1:-1)*10;
-        
-    var[3] = mcpt;      // pt 
-    var[4] = mceta;     // eta
-    var[5] = mcphi;     // phi    
-    var[6] = mcR;       // production radius
-    var[7] = mcStatus;  // internal status
-
-
-    (static_cast<THnSparseF *>(fDeOutputList->At(kMcElectron)))->Fill(var);
-}
-
-
-
-//__________________________________________________________
-void AliHFEdisplacedElectrons::FillEsdOutput(const AliESDEvent * const fESDEvent, AliESDtrack* const esdTrack, AliStack * const stack)
-{
-  // after esd event selection, esd track cuts, and hfe pid 
-  // this is the case for ESD tracks, with MC information
-
-  AliESDtrack *track = esdTrack;
-  Double_t pt  = track->Pt();
-  Double_t eta = track->Eta();
-  Double_t phi = track->Phi();
-  
-  Int_t eleLabel = track->GetLabel();
-  if(eleLabel<0 || eleLabel>stack->GetNtrack()) return;  
-
-  TParticle *particle = stack->Particle(eleLabel);
-  if(!particle) return;
-
-  // begin new stuff
-  Double_t mcR = particle->R();
-  Int_t mcStatus = particle->GetStatusCode();
-  // end new staff
-
-  // obtain impact parameters in xy and z
-  Float_t magneticField = 5;  // initialized as 5kG
-  magneticField = fESDEvent->GetMagneticField();  // in kG 
-  Double_t beampiperadius=3.;  
-  const AliESDVertex *primVtx = fESDEvent->GetPrimaryVertex();      
-
-  
-  const Int_t nvarESD = 9;
-  Double_t var[nvarESD];
-  var[0] = -1;
-
-  Int_t sourcePdg = -1;
-
-  if(TMath::Abs(particle->GetPdgCode())==kPDGelectron){
-    
-    sourcePdg = ElectronFromSource(stack, eleLabel);     
-    
-    if(sourcePdg==kPDGgamma){ // check direct photon or not 
-      if(ElePhotonDirect(stack, eleLabel)!=-1) 
-       var[0] = kEleDirectPhotonConv;    
-      else     
-       var[0] = kElePhotonConv;     
-      if(fDeDebugLevel>=10) 
-       printf("photonconv=====this electron %d is from %d, source id=%.1f\n", eleLabel, sourcePdg, var[0]);   
-    } else if(sourcePdg==kPDGpi0){ // check dalitz     
-      var[0] = kElePi0;   
-      if(fDeDebugLevel>=10) printf("pi0======this electron %d is from %d, source id=%.1f\n", eleLabel, sourcePdg, var[0]);    
-    } else if(sourcePdg==kPDGeta){ // check eta
-      var[0] = kEleEta;     
-      if(fDeDebugLevel>=10) 
-       printf("eta=====this electron %d is from %d, source id=%.1f\n", eleLabel, sourcePdg, var[0]);    
-    } else if(IsB(sourcePdg)) var[0] = kEleB; // check beauty
-      else if(IsC(sourcePdg)) var[0] = CheckCharm(stack,eleLabel); // check charm 
-    
-  } else if(TMath::Abs(particle->GetPdgCode())==kPDGpion) var[0] = kEleMissIDpion;
-  else var[0] = kEleMissID;
-  // ---- PID END ---- 
-  
-
-  // excluding current track
-  // ---- beginning --- method from Andrea D 28.05.2010
-  AliVertexerTracks *vertexer = new AliVertexerTracks(magneticField);
-  vertexer->SetITSMode();
-  vertexer->SetMinClusters(fNclustersITS);
-  Int_t skipped[2];
-  skipped[0] = (Int_t)track->GetID();
-  vertexer->SetSkipTracks(1,skipped);
-  AliESDVertex *vtxESDSkip = (AliESDVertex*)vertexer->FindPrimaryVertex(fESDEvent);
-  delete vertexer; vertexer = NULL;
-  if(vtxESDSkip->GetNContributors()<fMinNprimVtxContributor) return;
-  // -- ending --- method from Andrea D 28.05.2010 
-  
-  Double_t dz[2];   // error of dca in cm
-  Double_t covardz[3];
-  if(!track->PropagateToDCA(vtxESDSkip,magneticField, beampiperadius, dz, covardz)) return; // protection    
-  
-  Double_t dcaXY = dz[0]*1.0e4;  // conv dca in cm to dca in micron 
-  Double_t dcaZ = dz[1]*1.0e4;  
-  
-  if(fDeDebugLevel>=10) printf("others----->electron %d has mother %d is from %.1f\n", eleLabel, ElectronFromSource(stack, eleLabel), var[0]);
-  
-  if(TMath::Abs(dcaXY)<1000) var[1] = Int_t(dcaXY)/50;   // larger than 1mm should go to the last bin
-  else
-    var[1] = ((dcaXY>0)?1:-1)*20;
-  
-  if(TMath::Abs(dcaZ)<1000) var[2] = Int_t(dcaZ)/100;
-  else
-    var[2] = ((dcaZ>0)?1:-1)*10;
-  
-  // calculate dca using AliKFParticle class------------------------------------------------------------------
-  Float_t  kfDcaXY = 0;
-  Int_t trkID = track->GetID();  
-  AliKFParticle::SetField(magneticField);
-  AliKFParticle kfParticle(*track, particle->GetPdgCode());  
-  // prepare kfprimary vertex
-  AliKFVertex kfESDprimary;
-  // Reconstruct Primary Vertex (with ESD tracks)
-  Int_t n=primVtx->GetNIndices();
-  if (n>0 && primVtx->GetStatus()){
-    kfESDprimary = AliKFVertex(*primVtx);        
-    UShort_t *priIndex = primVtx->GetIndices();    
-    for (Int_t i=0;i<n;i++){
-      Int_t idx = Int_t(priIndex[i]);
-      if (idx == trkID){
-       kfESDprimary -= kfParticle;
-       kfDcaXY = kfParticle.GetDistanceFromVertexXY(kfESDprimary)*1e4;
-      }  // remove current track from this calculation
-    }  // loop over all primary vertex contributors    
-  }
-  // end of KF dca
-  
-  if(TMath::Abs(kfDcaXY)<1000) 
-    var[3] = Int_t(kfDcaXY)/50;
-  else
-    var[3] = (kfDcaXY>0?1:-1)*20;
-  
-  var[4] = pt;  // pt 
-  var[5] = eta; // eta
-  var[6] = phi; // phi    
-  var[7] = mcR;
-  var[8] = mcStatus;
-  
-  (static_cast<THnSparseF *>(fDeOutputList->At(kEsdElectron)))->Fill(var);
-  
-}
-
-//__________________________________________________________
-void AliHFEdisplacedElectrons::FillDataOutput(const AliESDEvent * const fESDEvent, AliESDtrack* const esdTrack)
-{
-  
-  // this is pure data, without MC information at all
-  // fill output: with HFE pid selection of electrons after all track quality cuts 
-
-  if(!esdTrack) return;
-  AliESDtrack *track = esdTrack;
-  
-  Double_t pt   = track->Pt();
-  Double_t eta = track->Eta();
-  Double_t phi = track->Phi();
-  
-  // obtain impact parameters in xy and y
-  const AliESDVertex *primVtx = fESDEvent->GetPrimaryVertex();    
-  
-  Float_t magneticField = 5;  // initialized as 5kG
-  magneticField = fESDEvent->GetMagneticField();  // in kG 
-  Double_t beampiperadius=3.;     
-  
-  const Int_t nvarData = 6;
-  Double_t varData[nvarData]; 
-    
-  //
-  // excluding current track
-  //
-  
-  //------ beginning --- method from Andrea D 28.05.2010
-  AliVertexerTracks *vertexer = new AliVertexerTracks(fESDEvent->GetMagneticField());
-  vertexer->SetITSMode();
-  vertexer->SetMinClusters(fNclustersITS);
-  Int_t skipped[2];
-  skipped[0] = (Int_t)track->GetID();
-  vertexer->SetSkipTracks(1,skipped);
-  AliESDVertex *vtxESDSkip = (AliESDVertex*)vertexer->FindPrimaryVertex(fESDEvent);
-  delete vertexer; vertexer = NULL;
-  if(vtxESDSkip->GetNContributors()<fMinNprimVtxContributor) return;
-  //------ ending --- method from Andrea D 28.05.2010 
-  Double_t dz[2];   // error of dca in cm
-  Double_t covardz[3];
-
-  if(!track->PropagateToDCA(vtxESDSkip,magneticField, beampiperadius, dz, covardz)) return; // protection 
-  
-  Double_t dcaXY = dz[0]*1.0e4;  // conv dca in cm to dca in micron 
-  Double_t dcaZ = dz[1]*1.0e4;
-   
-  if(TMath::Abs(dcaXY)<1000) varData[0] = Int_t(dcaXY)/50;   // larger than 1mm should go to the last bin
-  else
-    varData[0] = (dcaXY>0?1:-1)*20;
-  if(TMath::Abs(dcaZ)<1000) varData[1] = Int_t(dcaZ)/100;
-  else
-    varData[1] = (dcaZ>0?1:-1)*10;
-
-
-  // calculate dca using AliKFParticle class------------------------------------------------------------------
-  Float_t  kfDcaXY = 0;
-  Int_t trkID = track->GetID();  
-  AliKFParticle::SetField(magneticField);
-  AliKFParticle kfParticle(*track, -11*track->Charge());  
-  // prepare kfprimary vertex
-  AliKFVertex kfESDprimary;
-  // Reconstruct Primary Vertex (with ESD tracks)
-  Int_t n=primVtx->GetNIndices();
-  if (n>0 && primVtx->GetStatus()){
-    kfESDprimary = AliKFVertex(*primVtx);        
-    UShort_t *priIndex = primVtx->GetIndices();    
-    for (Int_t i=0;i<n;i++){
-      Int_t idx = Int_t(priIndex[i]);
-      if (idx == trkID){
-         kfESDprimary -= kfParticle;
-         kfDcaXY = kfParticle.GetDistanceFromVertexXY(kfESDprimary)*1e4;
-      }  // remove current track from this calculation
-    }  // loop over all primary vertex contributors    
-  }
-  if(TMath::Abs(kfDcaXY)<1000)
-    varData[2] = Int_t(kfDcaXY)/50;
-  else
-    varData[2] = ((kfDcaXY)>0?1:-1)*20;
-  // end of KF dca
-
-  varData[3] = pt; // pt 
-  varData[4] = eta; //eta
-  varData[5] = phi; // phi
-  
-  (static_cast<THnSparseF *>(fDeOutputList->At(kDataElectron)))->Fill(varData);
-
-}
-
-//__________________________________________________________
-Int_t AliHFEdisplacedElectrons::ElectronFromSource(AliStack * const stack, Int_t label) const
-{
-
-  //
-  //  return electron source label via electron label
-  //
-
-  // kEleSource is supposed to be either photon conv, direct photon conv, pi0, eta, beauty --> 0, 1, 2, 3, 4
-
-  Int_t eleLabel = label;
-
-  if(eleLabel<0 || eleLabel>stack->GetNtrack()) return -1;
-
-  TParticle *particle = stack->Particle(eleLabel);
-  if(!particle) return -1;
-
-  Int_t motherLabel = particle->GetFirstMother();
-  if(motherLabel<0 || motherLabel>stack->GetNtrack()) return -1;
-  TParticle *motherPart = stack->Particle(motherLabel);
-  if(!motherPart) return -1;
-
-  Int_t pdgCode = TMath::Abs(motherPart->GetPdgCode());
-
-  if(pdgCode==kPDGelectron) {
-    if(fDeDebugLevel>=10) printf("particle label: %d...(motherLabel=%d : motherPdg=%d)  grandmother's pdg code was returned...%d \n",
-                              label, motherLabel, pdgCode, ElectronFromSource(stack, motherLabel));
-    return ElectronFromSource(stack, motherLabel);
-  }
-
-  return pdgCode;    
-
-}
-
-//__________________________________________________________
-Int_t AliHFEdisplacedElectrons::ElectronFromCharm(AliStack * const stack, Int_t label) const
-{
-  //
-  //  separate electron: kEleC from c->eX, kEleBC from b->c->eX
-  //
-
-  Int_t motherLabel = label;
-  TParticle *motherParticle = stack->Particle(motherLabel);  // mother part
-  if(!motherParticle) return -1;
-  Int_t gMotherLabel = motherParticle->GetFirstMother();  // grand mother
-  if(gMotherLabel<0 || gMotherLabel>stack->GetNtrack()) return -1;
-  
-  TParticle *gMotherPart = stack->Particle(gMotherLabel);
-  if(!gMotherPart) return -1;
-  
-  Int_t pdgCode = gMotherPart->GetPdgCode();
-  if(TMath::Abs(pdgCode%10000)/100==kPDGbeauty ||    // for special intermediate meson states: like 100553
-     TMath::Abs(pdgCode)/1000==kPDGbeauty || TMath::Abs(pdgCode)/100==kPDGbeauty || TMath::Abs(pdgCode)==kPDGbeauty) {
-    if(fDeDebugLevel>=10)  printf("this electron label %d is from mother %d, and finally from %d\n", label, ElectronFromSource(stack, label), pdgCode);
-    return kEleBC;
-  }  // for sure it is from BC
-  
-  else 
-    if(TMath::Abs(pdgCode%10000)/100==kPDGcharm ||  // for special intermediate meson states: like 100443, 10443, 204*3 (*=1, 2, 3, 4)
-       TMath::Abs(pdgCode)/1000==kPDGcharm || 
-       TMath::Abs(pdgCode)/100==kPDGcharm || 
-       TMath::Abs(pdgCode)==kPDGcharm){
-      
-      if(CharmFromBeauty(stack, gMotherLabel)!=-1) return kEleBC;
-      else return kEleC;
-      
-    }
-  
-    else
-      return -1;
-     
-}
-
-//__________________________________________________________
-Int_t AliHFEdisplacedElectrons::CharmFromBeauty(AliStack * const stack, Int_t hfLabel) const
-{
-
-  //
-  //  check if charm meson/hadron is from beauty decay
-  //  -1, not from beauty  
-  //  return the label of the mother of this charm hadron
-  //
-
-  Int_t charmLabel = hfLabel;
-  
-  //  AliStack *stack = fMC->Stack();
-  if(charmLabel<0 || charmLabel>stack->GetNtrack()) return -1;
-  TParticle *particle = stack->Particle(charmLabel);
-  if(!particle) return -1;
-
-  Int_t motherCharmLabel = particle->GetFirstMother();
-  if(motherCharmLabel<0 || motherCharmLabel>stack->GetNtrack()) return -1;
-
-  TParticle *motherCharmPart = stack->Particle(motherCharmLabel);
-  if(!motherCharmPart) return -1;
-
-  Int_t pdgCode = motherCharmPart->GetPdgCode();
-  
-  if(TMath::Abs(pdgCode%10000)/100==kPDGbeauty ||   // for special intermediate meson states: like 100553
-     TMath::Abs(pdgCode)/1000==kPDGbeauty || 
-     TMath::Abs(pdgCode)/100==kPDGbeauty || 
-     TMath::Abs(pdgCode)==kPDGbeauty) 
-    return motherCharmLabel;  
-  else 
-    if(TMath::Abs(pdgCode%10000)/100==kPDGcharm ||    // for special intermediate meson states: like 100443, 10443, 204*3 (*=1, 2, 3, 4)
-       TMath::Abs(pdgCode)/1000==kPDGcharm || 
-       TMath::Abs(pdgCode)/100==kPDGcharm) 
-      return CharmFromBeauty(stack, motherCharmLabel);   // loop over to see if charm is from beauty -- if yes, return the label of mother of the charm
-  
-    else
-      return -1;
-}
-
-//__________________________________________________________
-Int_t AliHFEdisplacedElectrons::ElePhotonDirect(AliStack * const stack, Int_t label) const 
-{
-  //
-  // electron is from photon, and check if this photon is direct
-  //
-
-  Int_t eleLabel = label;
-  
-  TParticle *particle = stack->Particle(eleLabel);
-  if(particle->GetFirstMother()<0 || particle->GetFirstMother()>stack->GetNtrack())
-    return -1;
-  
-  TParticle *photonPart = stack->Particle(particle->GetFirstMother());
-  if(!photonPart) 
-    return -1;
-  Int_t motherPhotonLabel = photonPart->GetFirstMother();
-  if(motherPhotonLabel<0 || motherPhotonLabel>stack->GetNtrack())
-    return -1;
-
-  TParticle *motherPhotonPart = stack->Particle(motherPhotonLabel);
-  if(!motherPhotonPart) 
-    return -1;
-  
-  Int_t pdgMotherPhoton = motherPhotonPart->GetPdgCode();
-  if(TMath::Abs(pdgMotherPhoton)<=10 || TMath::Abs(pdgMotherPhoton)==21)
-    return 1;
-
-  else 
-    return -1;
-
-
-}
-
-//__________________________________________________________
-Int_t AliHFEdisplacedElectrons::GetMCpid(AliStack* const stack, Int_t partLabel) const
-{
-
-  //
-  // Simply pdg code
-  //
-  
-  Int_t label = partLabel;
-//   AliStack* stack = fMC->Stack();
-  if((label < 0) || (label >= stack->GetNtrack())) return -1;  
-
-  // MC Information
-  TParticle * particle = stack->Particle(label);
-  if(!particle) return -1;
-  Int_t pdg = particle->GetPdgCode();
-
-  return pdg;
-}
-
-//__________________________________________________________
-Int_t AliHFEdisplacedElectrons::GetMotherLabel(AliStack *const stack, Int_t eleLabel) const 
-{
-  //
-  // Simply label of mother
-  //
-
-
-  Int_t label = eleLabel;
-  //  AliStack* stack = fMC->Stack();
-  if((label < 0) || (label >= stack->GetNtrack())) return -1;  
-
-  // MC Information
-  TParticle * particle = stack->Particle(label);
-  if(!particle) return -1;
-
-  return particle->GetFirstMother();
-}
-
-
-//__________________________________________________________
-Float_t AliHFEdisplacedElectrons::GetRapidity(TParticle *part) const
-{
-  // return rapidity
-  
-  Float_t rapidity = -999;        
-  if((part->Energy() - part->Pz())*(part->Energy() + part->Pz())>0)
-    rapidity = 0.5*(TMath::Log((part->Energy()+part->Pz()) / (part->Energy()-part->Pz()))); 
-  
-  return rapidity;
-}
-
-
-//__________________________________________________________
-Float_t AliHFEdisplacedElectrons::GetTrackRapidity(AliESDtrack * const track) const
-{
-  // return rapidity of electron
-  
-  Float_t px = track->Px();
-  Float_t py = track->Py();
-  Float_t pz = track->Pz();
-
-  // electron mass 0.00051099906 GeV/c2
-  TParticlePDG* electron = TDatabasePDG::Instance()->GetParticle(kPDGelectron);
-  Double_t mass = electron->Mass();
-  
-  Float_t en = TMath::Sqrt(px*px + py*py + pz*pz + mass*mass);
-
-  Float_t rapidity = -999;        
-  if((en - pz)*(en + pz)>0)
-    rapidity = 0.5*(TMath::Log((en - pz)*(en + pz))); 
-  
-  return rapidity;
-}
-
-//__________________________________________________________
-Int_t AliHFEdisplacedElectrons::CheckCharm(AliStack * const stack, Int_t eleLabel)
-{
-  // checks the genealogy of the ele from charm for a beauty
-  // this method needs the stack and the label of the electron
-  // warning: it assumes that the ele comes from a charm
-
-  TParticle *particle = stack->Particle(eleLabel);
-  Int_t label = particle->GetFirstMother();
-
-  while(label>0 && label<(stack->GetNtrack())){
-    particle = stack->Particle(label);
-    if(IsB(TMath::Abs(particle->GetPdgCode()))) return kEleBC;
-    label = particle->GetFirstMother();
-  }
-
-  return kEleC; 
-}
-
-//__________________________________________________________
-Bool_t AliHFEdisplacedElectrons::IsB(Int_t pdg) const
-{
-  // check if the pdg is that of a beauty particle
-  if((TMath::Abs(pdg)%10000)/100==kPDGbeauty ||  
-     TMath::Abs(pdg)/1000==kPDGbeauty ||      
-     TMath::Abs(pdg)/100==kPDGbeauty ||     
-     TMath::Abs(pdg)==kPDGbeauty) return kTRUE;
-  else return kFALSE;
-} 
-
-//__________________________________________________________
-Bool_t AliHFEdisplacedElectrons::IsC(Int_t pdg) const
-{
-  // check if the pdg is that of a charmed particle
-   
-  if((TMath::Abs(pdg)%10000)/100==kPDGcharm ||   
-     TMath::Abs(pdg)/1000==kPDGcharm ||       
-     TMath::Abs(pdg)/100==kPDGcharm ||        
-     TMath::Abs(pdg)==kPDGcharm) return kTRUE;
-  else return kFALSE; 
-}
diff --git a/PWGHF/hfe/AliHFEdisplacedElectrons.h b/PWGHF/hfe/AliHFEdisplacedElectrons.h
deleted file mode 100644 (file)
index 1790e42..0000000
+++ /dev/null
@@ -1,163 +0,0 @@
-/**************************************************************************
-* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
-*                                                                        *
-* Author: The ALICE Off-line Project.                                    *
-* Contributors are mentioned in the code where appropriate.              *
-*                                                                        *
-* Permission to use, copy, modify and distribute this software and its   *
-* documentation strictly for non-commercial purposes is hereby granted   *
-* without fee, provided that the above copyright notice appears in all   *
-* copies and that both the copyright notice and this permission notice   *
-* appear in the supporting documentation. The authors make no claims     *
-* about the suitability of this software for any purpose. It is          *
-* provided "as is" without express or implied warranty.                  *
-**************************************************************************/
-//
-// Class for electrons from beauty study
-// Counting electrons from beauty
-// by DCA cuts, background subtraction 
-//
-// Authors:
-//  Hongyan Yang <hongyan@physi.uni-heidelberg.de>
-//  Carlo Bombonati <Carlo.Bombonati@cern.ch>
-// 
-
-#ifndef ALIHFEDISPLACEDELECTRONS_H
-#define ALIHFEDISPLACEDELECTRONS_H
-
-#ifndef ROOT_TObject
-#include <TObject.h>
-#endif
-
-#ifndef ROOT_TPDGCode
-#include <TPDGCode.h>
-#endif
-
-class TChain;
-class TTree;
-class TFile;
-
-class TPDGCode;
-
-class TString;
-class TList;
-
-class AliLog;
-
-class THnSparse;
-
-class TObjArray;
-class AliStack;
-class AliMCEvent;
-class AliESDEvent;
-class AliVEvent;
-
-class AliESDtrack;
-class AliESDVertex;
-
-class AliHFEdisplacedElectrons : public TObject{
-
- public:  
-
-  enum{
-    kPDGelectron = kElectron,
-    kPDGgamma = kGamma,
-    kPDGpi0 = kPi0,
-    kPDGpion = kPiPlus, 
-    kPDGeta = 221,
-    kPDGcharm = kCharm,
-    kPDGbeauty = kBottom
-  };  // PDG codes to be used
-
-  AliHFEdisplacedElectrons(); // default constructor
-  AliHFEdisplacedElectrons(const AliHFEdisplacedElectrons &p); // copy constructor
-  AliHFEdisplacedElectrons &operator=(const AliHFEdisplacedElectrons &ref); // assignment operator
-
-  virtual ~AliHFEdisplacedElectrons();
-
-  void InitAnalysis();  
-  void CreateOutputs(TList* const displacedList);
-
-  void FillMcOutput(const AliESDEvent * const fESD, AliMCEvent * const fMC, const AliMCParticle * const mctrack);
-  void FillEsdOutput(const AliESDEvent * const fESDEvent, AliESDtrack * const track, AliStack *stack);
-  void FillDataOutput(const AliESDEvent * const fESDEvent, AliESDtrack * const track);
-
-  Int_t GetMCpid(AliStack* stack, Int_t label) const;
-
-  Bool_t HasMCData() const { return TestBit(kHasMCData); };
-  void SetHasMCData(Bool_t hasMCdata = kTRUE) { SetBit(kHasMCData,hasMCdata); };
-  void SetDebugLevel(Int_t debugLevel){ fDeDebugLevel = debugLevel; };
-  void SetNitsCluster(Int_t nITScls){ fNclustersITS = nITScls;};
-  void SetMinPrimVtxContrib(Int_t nContrib){fMinNprimVtxContributor = nContrib;};
-
-  //void PostAnalysis() const;
-
-
- private:
-
-  enum{
-    kHasMCData = BIT(15),             // bitset for mc data usage
-    kHasESDData = BIT(16)
-  };
-   
-
-
-  enum{
-    kElePhotonConv = 0,
-    kEleDirectPhotonConv = 1,
-    kElePi0 = 2,
-    kEleEta = 3, 
-    kEleB = 4, 
-    kEleC = 5, 
-    kEleBC = 6,
-    kEleMissID = 7,
-    kEleMissIDpion = 8,
-    kPion = 8
-  };  // electron source index
-  
-  enum{
-    kMcElectron = 0, 
-    kEsdElectron = 1, 
-    kDataElectron = 2
-  };  // MC or Data
-
-  enum{
-    kNDcaMin = 42, 
-    kNPtIntv = 14, 
-    kNKineVar = 3
-  };   // several constant to be used
-
-  Int_t CheckCharm(AliStack *const stack, Int_t eleLabel);
-  Bool_t IsB(Int_t pdg) const;
-  Bool_t IsC(Int_t pdg) const;
-  Int_t ElectronFromSource(AliStack *stack, Int_t eleLabel) const;
-  Int_t ElePhotonDirect(AliStack *stack, Int_t label) const;
-  Int_t ElectronFromCharm(AliStack *stack, Int_t eleLabel) const;
-  Int_t CharmFromBeauty(AliStack *stack, Int_t charmLabel) const;
-  
-  Int_t GetMotherLabel(AliStack *stack, Int_t label) const;
-  Float_t GetRapidity(TParticle *part) const;
-  Float_t GetTrackRapidity(AliESDtrack *track) const;
-
-  static const Float_t fgkDcaMinIntv[kNDcaMin];  // DCA cut min limit
-  static const Float_t fgkDcaMinPtIntv[kNPtIntv-1]; // DCA cut min limit in different pT bins
-  static const Float_t fgkPtIntv[kNPtIntv]; // all pt bins
-
-  static const Char_t *fgkKineVar[kNKineVar];  // particle names
-  static const Char_t *fgkKineVarTitle[kNKineVar];  // particle names
-  
-  UInt_t fDeDebugLevel;   // debug level
-  Int_t fNclustersITS;  // ITS clusters
-  Int_t fMinNprimVtxContributor;      // minimum number of contributors to the primary vtx
-
-  THnSparseF *fTHnSparseDcaMcEleInfo;   //! container for MC pion part
-  THnSparseF *fTHnSparseDcaEsdEleInfo;   //! container for MC electron part
-  THnSparseF *fTHnSparseDcaDataEleInfo; //! container for Data electron part
-
-  TList *fDeOutputList;  //! output container
-  ClassDef(AliHFEdisplacedElectrons, 0);
-};
-
-#endif
index 664a5ee..f7cf229 100644 (file)
@@ -49,7 +49,7 @@
 
 ClassImp(AliHFEextraCuts)
 
-const Int_t AliHFEextraCuts::fgkNQAhistos = 8;
+const Int_t AliHFEextraCuts::fgkNQAhistos = 9;
 
 //______________________________________________________
 AliHFEextraCuts::AliHFEextraCuts(const Char_t *name, const Char_t *title):
@@ -61,6 +61,7 @@ AliHFEextraCuts::AliHFEextraCuts(const Char_t *name, const Char_t *title):
   fMinNClustersTPCPID(0),
   fClusterRatioTPC(0.),
   fMinTrackletsTRD(0),
+  fMaxChi2TRD(5.0),
   fMinNbITScls(0),
   fTRDtrackletsExact(0),
   fPixelITS(0),
@@ -93,6 +94,7 @@ AliHFEextraCuts::AliHFEextraCuts(const AliHFEextraCuts &c):
   fMinNClustersTPCPID(c.fMinNClustersTPCPID),
   fClusterRatioTPC(c.fClusterRatioTPC),
   fMinTrackletsTRD(c.fMinTrackletsTRD),
+  fMaxChi2TRD(c.fMaxChi2TRD),
   fMinNbITScls(c.fMinNbITScls),
   fTRDtrackletsExact(c.fTRDtrackletsExact),
   fPixelITS(c.fPixelITS),
@@ -134,6 +136,7 @@ AliHFEextraCuts &AliHFEextraCuts::operator=(const AliHFEextraCuts &c){
     fMinNClustersTPC = c.fMinNClustersTPC;
     fMinNClustersTPCPID = c.fMinNClustersTPCPID;
     fMinTrackletsTRD = c.fMinTrackletsTRD;
+    fMaxChi2TRD      = c.fMaxChi2TRD;
     fMinNbITScls = c.fMinNbITScls;
     fTRDtrackletsExact = c.fTRDtrackletsExact;
     fPixelITS = c.fPixelITS;
@@ -204,7 +207,7 @@ Bool_t AliHFEextraCuts::CheckRecCuts(AliVTrack *track){
   // QA histograms are filled before track selection and for
   // selected tracks after track selection
   //
-  AliDebug(1, "Called");
+  AliDebug(1, Form("%s: Called", GetName()));
   ULong64_t survivedCut = 0;   // Bitmap for cuts which are passed by the track, later to be compared with fRequirements
   if(IsQAOn()) FillQAhistosRec(track, kBeforeCuts);
   // Apply cuts
@@ -227,6 +230,8 @@ Bool_t AliHFEextraCuts::CheckRecCuts(AliVTrack *track){
   Double_t ratioTPC = GetTPCclusterRatio(track);
   UChar_t trdTracklets;
   trdTracklets = track->GetTRDntrackletsPID();
+  Float_t trdchi2=-999.;
+  trdchi2=GetTRDchi(track);
   UChar_t itsPixel = track->GetITSClusterMap();
   Int_t status1 = GetITSstatus(track, 0);
   Int_t status2 = GetITSstatus(track, 1);
@@ -295,36 +300,45 @@ Bool_t AliHFEextraCuts::CheckRecCuts(AliVTrack *track){
   }
   if(TESTBIT(fRequirements, kMinTrackletsTRD)){
     // cut on minimum number of TRD tracklets
-    AliDebug(1, Form("Min TRD cut: [%d|%d], Require exact number [%s]\n", fMinTrackletsTRD, trdTracklets, fTRDtrackletsExact ? "Yes" : "No"));
+    AliDebug(1, Form("%s: Min TRD cut: [%d|%d], Require exact number [%s]\n", GetName(), fMinTrackletsTRD, trdTracklets, fTRDtrackletsExact ? "Yes" : "No"));
     if(fTRDtrackletsExact){
       if(trdTracklets == fMinTrackletsTRD) {
         SETBIT(survivedCut, kMinTrackletsTRD);
-        AliDebug(1, "Track Selected");
+        AliDebug(1, Form("%s: Track Selected", GetName()));
       }
     }else{
       if(trdTracklets >= fMinTrackletsTRD){ 
         SETBIT(survivedCut, kMinTrackletsTRD);
-        AliDebug(1, "Track Selected");
+        AliDebug(1, Form("%s: Track Selected", GetName()));
       }
       //printf("Min number of tracklets %d\n",fMinTrackletsTRD);
     }
   }
-  
+
+  if(TESTBIT(fRequirements, kMaxTRDChi2)){
+    // cut on TRD chi2
+    AliDebug(1, Form("%s: Cut on TRD chi2: [%f|%f]\n", GetName(),fMaxChi2TRD, trdchi2));
+    if(trdchi2 < fMaxChi2TRD) {
+       SETBIT(survivedCut, kMaxTRDChi2);
+        AliDebug(1,Form("%s: survived %f\n",GetName(),trdchi2));
+    }
+  }
+
   if(TESTBIT(fRequirements, kMinNbITScls)){
     // cut on minimum number of ITS clusters
     //printf(Form("Min ITS clusters: [%d|%d]\n", (Int_t)fMinNbITScls, nclsITS));
-    AliDebug(1, Form("Min ITS clusters: [%d|%d]\n", fMinNbITScls, nclsITS));
+    AliDebug(1, Form("%s: Min ITS clusters: [%d|%d]\n", GetName(), fMinNbITScls, nclsITS));
     if(nclsITS >= ((Int_t)fMinNbITScls)) SETBIT(survivedCut, kMinNbITScls);
   }
   
   if(TESTBIT(fRequirements, kMinNClustersTPC)){
     // cut on minimum number of TPC tracklets
     //printf(Form("Min TPC cut: [%d|%d]\n", fMinNClustersTPC, nclsTPC));
-    AliDebug(1, Form("Min TPC cut: [%d|%d]\n", fMinNClustersTPC, nclsTPC));
+    AliDebug(1, Form("%s: Min TPC cut: [%d|%d]\n", GetName(), fMinNClustersTPC, nclsTPC));
     if(nclsTPC >= fMinNClustersTPC) SETBIT(survivedCut, kMinNClustersTPC);
   }
   if(TESTBIT(fRequirements, kMinNClustersTPCPID)){
-    AliDebug(1, Form("Min TPC PID cut: [%d|%d]\n", fMinNClustersTPCPID, nclsTPCPID));
+    AliDebug(1, Form("%s: Min TPC PID cut: [%d|%d]\n", GetName(), fMinNClustersTPCPID, nclsTPCPID));
     if(nclsTPCPID >= fMinNClustersTPCPID) SETBIT(survivedCut, kMinNClustersTPCPID);
   }
   if(TESTBIT(fRequirements, kDriftITS)){
@@ -340,7 +354,7 @@ Bool_t AliHFEextraCuts::CheckRecCuts(AliVTrack *track){
   }
   if(TESTBIT(fRequirements, kPixelITS)){
     // cut on ITS pixel layers
-    AliDebug(1, "ITS cluster Map: ");
+    AliDebug(1, Form("%s: ITS cluster Map: ", GetName()));
     //PrintBitMap(itsPixel);
     switch(fPixelITS){
       case kFirst:
@@ -399,7 +413,7 @@ Bool_t AliHFEextraCuts::CheckRecCuts(AliVTrack *track){
         SETBIT(survivedCut, kPixelITS);
         break;
     }
-    AliDebug(1, Form("Survived Cut: %s\n", TESTBIT(survivedCut, kPixelITS) ? "YES" : "NO"));
+    AliDebug(1, Form("%s: Survived Cut: %s\n", GetName(), TESTBIT(survivedCut, kPixelITS) ? "YES" : "NO"));
   }
 
   if(TESTBIT(fRequirements, kTOFPID)){
@@ -437,16 +451,20 @@ Bool_t AliHFEextraCuts::CheckRecCuts(AliVTrack *track){
     // cut on TOF matching cluster
     if((TMath::Abs(tofsignalDx) <= fTOFsignalDx) && (TMath::Abs(tofsignalDz) <= fTOFsignalDz)) SETBIT(survivedCut, kTOFsignalDxy);
   }
+  if(TESTBIT(fRequirements, kITSpattern)){
+    // cut on ITS pattern (every layer with a working ITS module must have an ITS cluster)
+    if(CheckITSpattern(track)) SETBIT(survivedCut, kITSpattern); 
+  }
   
   if(fRequirements == survivedCut){
-    //
+    // 
     // Track selected
     //
-    AliDebug(2, "Track Survived cuts\n");
+    AliDebug(2, Form("%s: Track Survived cuts\n", GetName()));
     if(IsQAOn()) FillQAhistosRec(track, kAfterCuts);
     return kTRUE;
   }
-  AliDebug(2, "Track cut");
+  AliDebug(2, Form("%s: Track cut", GetName()));
   if(IsQAOn()) FillCutCorrelation(survivedCut);
   return kFALSE;
 }
@@ -506,6 +524,8 @@ void AliHFEextraCuts::FillQAhistosRec(AliVTrack *track, UInt_t when){
     if(GetTPCCountSharedMapBitsAboveThreshold(track)==0) hStatusBits->Fill(4);
   }
   if((htmp = dynamic_cast<TH1F *>(fQAlist->At(7 + when * fgkNQAhistos)))) htmp->Fill(track->GetTPCsignalN());
+
+  if((htmp = dynamic_cast<TH1F *>(fQAlist->At(8 + when * fgkNQAhistos)))) htmp->Fill(GetTRDchi(track));
 }
 
 // //______________________________________________________
@@ -589,6 +609,11 @@ void AliHFEextraCuts::AddQAHistograms(TList *qaList){
     fQAlist->AddAt(histo1D, 7 + icond * fgkNQAhistos);
     histo1D->GetXaxis()->SetTitle("Number of TPC clusters for dEdx calculation");
     histo1D->GetYaxis()->SetTitle("counts");
+    qaList->AddAt((histo1D = new TH1F(Form("%s_trdchi2perTracklet%s",GetName(),cutstr[icond].Data()), "chi2 per TRD tracklet", 100, 0, 10)), 8 + icond * fgkNQAhistos);
+    fQAlist->AddAt(histo1D, 8 + icond * fgkNQAhistos);
+    histo1D->GetXaxis()->SetTitle("Chi2 per TRD Tracklet");
+    histo1D->GetYaxis()->SetTitle("Number of Tracks");
+
   }
   // Add cut correlation
   qaList->AddAt((histo2D = new TH2F(Form("%s_cutcorrelation",GetName()), "Cut Correlation", kNcuts, 0, kNcuts - 1, kNcuts, 0, kNcuts -1)), 2 * fgkNQAhistos);
@@ -624,7 +649,7 @@ Bool_t AliHFEextraCuts::CheckITSstatus(Int_t itsStatus) const {
 }
 
 //______________________________________________________
-Int_t AliHFEextraCuts::GetITSstatus(AliVTrack *track, Int_t layer){
+Int_t AliHFEextraCuts::GetITSstatus(const AliVTrack * const track, Int_t layer) const {
        //
        // Check ITS layer status
        //
@@ -632,7 +657,7 @@ Int_t AliHFEextraCuts::GetITSstatus(AliVTrack *track, Int_t layer){
        if(!TString(track->IsA()->GetName()).CompareTo("AliESDtrack")){
                Int_t det;
                Float_t xloc, zloc;
-               AliESDtrack *esdtrack = dynamic_cast<AliESDtrack *>(track);
+               const AliESDtrack *esdtrack = dynamic_cast<const AliESDtrack *>(track);
                if(esdtrack) esdtrack->GetITSModuleIndexInfo(layer, det, status, xloc, zloc);
        }
        return status;
@@ -824,6 +849,31 @@ Bool_t AliHFEextraCuts::IsKinkMother(AliVTrack *track){
   return kFALSE;
 
 }
+
+//______________________________________________________
+Float_t AliHFEextraCuts::GetTRDchi(AliVTrack *track){
+  //
+  // Get TRDchi2
+  //
+  Int_t ntls(0);
+  TClass *type = track->IsA();
+  if(type == AliESDtrack::Class()){
+      AliESDtrack *esdtrack = static_cast<AliESDtrack *>(track);
+      ntls = esdtrack->GetTRDntracklets();
+      return ntls ? esdtrack->GetTRDchi2()/ntls : -999;
+  }
+  else if(type == AliAODTrack::Class()){
+    AliAODTrack *aodtrack = dynamic_cast<AliAODTrack *>(track);
+    if(aodtrack){
+      return  999.;
+    }
+  }
+
+  return 999.;
+
+}
+
+
 //______________________________________________________
 Int_t AliHFEextraCuts::GetITSNbOfcls(AliVTrack *track){
   //
@@ -1052,3 +1102,25 @@ void AliHFEextraCuts::GetTOFsignalDxDz(AliVTrack *track, Double_t &tofsignalDx,
   }
 
 }
+
+//______________________________________________________
+Bool_t AliHFEextraCuts::CheckITSpattern(const AliVTrack *const track) const {
+  //
+  // Check if every ITS layer, which has a module which is alive, also
+  // has an ITS cluster
+  //
+  Bool_t patternOK(kTRUE);
+  Int_t status(0);
+  for(Int_t ily = 0; ily < 6; ily++){
+    status = GetITSstatus(track, ily);
+    if(CheckITSstatus(status)){
+      // pixel alive, check whether layer has a cluster
+      if(!TESTBIT(track->GetITSClusterMap(),ily)){
+        // No cluster even though pixel is alive - reject track
+        patternOK = kFALSE;
+        break;
+      }
+    }
+  }
+  return patternOK;
+}
index 418d2cb..a7051c9 100644 (file)
@@ -72,6 +72,7 @@ class AliHFEextraCuts: public AliCFCutBase{
     inline void SetMaxImpactParamZ(Double_t impactParam);
     inline void SetMinHFEImpactParamR(Float_t ipcutParam[4], Bool_t issigmacut, Bool_t isabs);
     inline void SetMinTrackletsTRD(Int_t minTracklets, Bool_t exact = kFALSE);
+    inline void SetMaxChi2TRD(Float_t maxchi2);
     inline void SetMinNClustersTPC(Int_t minclusters, ETPCclusterDef_t def);
     void SetMinNClustersTPCPID(Int_t minclusters) { SETBIT(fRequirements, kMinNClustersTPCPID); fMinNClustersTPCPID = minclusters; }
     void SetTOFPID(Bool_t tofPid) { tofPid ? SETBIT(fRequirements, kTOFPID) : CLRBIT(fRequirements, kTOFPID); }
@@ -84,14 +85,16 @@ class AliHFEextraCuts: public AliCFCutBase{
     void SetRejectKinkDaughter() { SETBIT(fRequirements, kRejectKinkDaughter);}; 
     void SetRejectKinkMother() { SETBIT(fRequirements, kRejectKinkMother);}; 
     void SetCheckITSstatus(Bool_t check) { fCheck = check; };
+    void SetITSpatternCut() { SETBIT(fRequirements, kITSpattern); }
     void SetDebugLevel(Int_t level) { fDebugLevel = level; };
 
     Bool_t GetCheckITSstatus() const { return fCheck; };
     Int_t GetDebugLevel() const { return fDebugLevel; };
     void GetHFEImpactParameters(AliVTrack *track, Double_t &dcaxy, Double_t &dcansigmaxy); // temporary moved from protected to publich for IP QA 
     void GetHFEImpactParameters(AliVTrack *track, Double_t dcaD[2], Double_t covD[3]);
-    Int_t GetITSstatus(AliVTrack *track, Int_t layer);
+    Int_t GetITSstatus(const AliVTrack * const track, Int_t layer) const;
     Bool_t CheckITSstatus(Int_t itsStatus) const;
+    Bool_t CheckITSpattern(const AliVTrack *const track) const;
 
     void UnSetRejectKinkDaughter() { CLRBIT(fRequirements, kRejectKinkDaughter);}; 
     void UnSetRejectKinkMother() { CLRBIT(fRequirements, kRejectKinkMother);}; 
@@ -116,6 +119,7 @@ class AliHFEextraCuts: public AliCFCutBase{
     void GetMaxImpactParameterCutR(AliVTrack *track, Double_t &maximpactRcut);
     void GetTOFsignalDxDz(AliVTrack *track, Double_t &tofsignalDx, Double_t &tofsignalDz);
     Float_t GetTPCsharedClustersRatio(AliVTrack *track);
+    Float_t GetTRDchi(AliVTrack *track);
     Int_t GetITSNbOfcls(AliVTrack *track);
     Bool_t IsKinkDaughter(AliVTrack *track);
     Bool_t IsKinkMother(AliVTrack *track);
@@ -144,7 +148,9 @@ class AliHFEextraCuts: public AliCFCutBase{
       kRejectKinkMother = 19,
       kDriftITS = 20,
       kTOFsignalDxy = 21,
-      kNcuts = 22
+      kMaxTRDChi2 = 22,
+      kITSpattern = 23,
+      kNcuts = 24
     } Cut_t;
     enum{
       //
@@ -163,6 +169,7 @@ class AliHFEextraCuts: public AliCFCutBase{
     UInt_t fMinNClustersTPCPID;       // Minimum TPC PID clusters cut
     Float_t fClusterRatioTPC;        // Ratio of findable vs. found clusters in TPC
     UChar_t fMinTrackletsTRD;        // Min. Number of Tracklets inside TRD
+    Float_t fMaxChi2TRD;             // Max chi2 TRD
     UChar_t fMinNbITScls;            // Min. Number of ITS clusters
     Bool_t  fTRDtrackletsExact;       // Require exact number of tracklets
     UChar_t fPixelITS;                // Cut on ITS Pixels
@@ -243,6 +250,13 @@ void AliHFEextraCuts::SetMinTrackletsTRD(Int_t minTracklets, Bool_t exact){
 }
 
 //__________________________________________________________
+void AliHFEextraCuts::SetMaxChi2TRD(Float_t maxchi2){
+  SETBIT(fRequirements, kMaxTRDChi2);
+  fMaxChi2TRD = maxchi2;
+}
+
+
+//__________________________________________________________
 void AliHFEextraCuts::SetMinNClustersTPC(Int_t minClusters, ETPCclusterDef_t tpcdef){
   SETBIT(fRequirements, kMinNClustersTPC);
   SETBIT(fTPCclusterDef, tpcdef);
index fbea85a..54e0413 100644 (file)
@@ -360,7 +360,7 @@ void AliHFEmcQA::CreateHistograms(const Int_t kquark)
     fHistComm[iq][icut].fPtCorrD0 = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1);
     hname = kqEtaRangeLabel[icut]+"PtCorrDrest_"+kqTypeLabel[kQuark];
     fHistComm[iq][icut].fPtCorrDrest = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1);
-  
+
     hname = kqEtaRangeLabel[icut]+"ePtRatio_"+kqTypeLabel[kQuark];
     fHistComm[iq][icut].fePtRatio = new TH2F(hname,hname+";p_{T} (GeV/c);momentum fraction",200,0,20,100,0,1);
     hname = kqEtaRangeLabel[icut]+"DePtRatio_"+kqTypeLabel[kQuark];
@@ -369,9 +369,80 @@ void AliHFEmcQA::CreateHistograms(const Int_t kquark)
     fHistComm[iq][icut].feDistance= new TH2F(hname,hname+";p_{T} (GeV/c);distance (cm)",100,0,20,200,0,2);
     hname = kqEtaRangeLabel[icut]+"DeDistance_"+kqTypeLabel[kQuark];
     fHistComm[iq][icut].fDeDistance= new TH2F(hname,hname+";p_{T} (GeV/c);distance (cm)",100,0,20,200,0,2);
+
+    if(icut <1){
+      hname = kqEtaRangeLabel[icut]+"PtCorrDinein_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrDinein = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrDineout_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrDineout = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrDoutein_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrDoutein = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrDouteout_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrDouteout = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+
+      hname = kqEtaRangeLabel[icut]+"PtCorrDpDinein_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrDpDinein = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrDpDineout_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrDpDineout = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrDpDoutein_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrDpDoutein = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrDpDouteout_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrDpDouteout = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+
+      hname = kqEtaRangeLabel[icut]+"PtCorrD0Dinein_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrD0Dinein = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrD0Dineout_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrD0Dineout = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrD0Doutein_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrD0Doutein = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrD0Douteout_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrD0Douteout = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+
+      hname = kqEtaRangeLabel[icut]+"PtCorrDrestDinein_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrDrestDinein = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrDrestDineout_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrDrestDineout = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrDrestDoutein_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrDrestDoutein = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrDrestDouteout_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrDrestDouteout = new TH2F(hname,hname+";D p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+
+      hname = kqEtaRangeLabel[icut]+"fEtaCorrD_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fEtaCorrD = new TH2F(hname,hname+";D Y;e eta",200,-10,10,200,-10,10); 
+      hname = kqEtaRangeLabel[icut]+"fEtaCorrDp_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fEtaCorrDp = new TH2F(hname,hname+";D Y;e eta",200,-10,10,200,-10,10); 
+      hname = kqEtaRangeLabel[icut]+"fEtaCorrD0_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fEtaCorrD0 = new TH2F(hname,hname+";D Y;e eta",200,-10,10,200,-10,10); 
+      hname = kqEtaRangeLabel[icut]+"fEtaCorrDrest_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fEtaCorrDrest = new TH2F(hname,hname+";D Y;e eta",200,-10,10,200,-10,10); 
+
+      hname = kqEtaRangeLabel[icut]+"fEtaCorrGD_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fEtaCorrGD = new TH2F(hname,hname+";D Y;e eta",200,-10,10,200,-10,10); 
+      hname = kqEtaRangeLabel[icut]+"fEtaCorrGDp_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fEtaCorrGDp = new TH2F(hname,hname+";D Y;e eta",200,-10,10,200,-10,10); 
+      hname = kqEtaRangeLabel[icut]+"fEtaCorrGD0_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fEtaCorrGD0 = new TH2F(hname,hname+";D Y;e eta",200,-10,10,200,-10,10); 
+      hname = kqEtaRangeLabel[icut]+"fEtaCorrGDrest_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fEtaCorrGDrest = new TH2F(hname,hname+";D Y;e eta",200,-10,10,200,-10,10); 
+
+      hname = kqEtaRangeLabel[icut]+"fEtaCorrB_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fEtaCorrB = new TH2F(hname,hname+";B Y;e eta",200,-10,10,200,-10,10); 
+      hname = kqEtaRangeLabel[icut]+"fEtaCorrGB_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fEtaCorrGB = new TH2F(hname,hname+";B Y;e eta",200,-10,10,200,-10,10); 
+
+      hname = kqEtaRangeLabel[icut]+"PtCorrBinein_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrBinein = new TH2F(hname,hname+";B p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrBineout_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrBineout = new TH2F(hname,hname+";B p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrBoutein_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrBoutein = new TH2F(hname,hname+";B p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+      hname = kqEtaRangeLabel[icut]+"PtCorrBouteout_"+kqTypeLabel[kQuark];
+      fHistComm[iq][icut].fPtCorrBouteout = new TH2F(hname,hname+";B p_{T} (GeV/c);e p_{T} (GeV/c)",ndptbins,xcorrbin,iBin[1],kPtbinning1); // new binning
+    }
     if(fQAhistos) fHistComm[iq][icut].FillList(fQAhistos);
   }
 
+
   hname = kqEtaRangeLabel[0]+"Nq_"+kqTypeLabel[kQuark];
   fHistComm[iq][0].fNq = new TH1F(hname,hname,50,-0.5,49.5);
   hname = kqEtaRangeLabel[0]+"ProcessID_"+kqTypeLabel[kQuark];
@@ -977,6 +1048,35 @@ void AliHFEmcQA::GetDecayedKine(TParticle* mcpart, const Int_t kquark, Int_t kde
                     fHist[iq][kDeHadron][2][fCentrality].fEta->Fill(grandMa->Eta());
                   }
 
+                  //mj: to calculate B to e eta correlation to calculate total heavy quark cross section
+                  Int_t kLabel0 = grandMa->GetFirstMother();
+                  Bool_t isGGrandmaYes = kFALSE;
+                  Double_t ggmrapidwstmp=0;
+                  if (!(kLabel0 < 0)){ // safety protection
+                    if((mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(kLabel0))))){
+                      TParticle* ggrandMatmp = mctrack->Particle();
+                      Int_t ggrandMaPDGtmp = ggrandMatmp->GetPdgCode();
+                      if ( int(abs(ggrandMaPDGtmp)/100.) == kBeauty || int(abs(ggrandMaPDGtmp)/1000.) == kBeauty) isGGrandmaYes = kTRUE;
+                      ggmrapidwstmp = AliHFEtools::GetRapidity(ggrandMatmp);
+                    }
+                  }
+
+                  Double_t gmrapidwstmp0 = AliHFEtools::GetRapidity(grandMa);
+                  Double_t eetawstmp0 = mcpart->Eta();
+  
+                  Double_t gmrapidtmp0 = TMath::Abs(gmrapidwstmp0);
+                  Double_t eetatmp0 = TMath::Abs(eetawstmp0);
+
+                  fHistComm[iq][0].fEtaCorrB->Fill(gmrapidwstmp0,eetawstmp0);
+                  if(isGGrandmaYes) fHistComm[iq][0].fEtaCorrGB->Fill(ggmrapidwstmp,eetawstmp0);
+                  else fHistComm[iq][0].fEtaCorrGB->Fill(gmrapidwstmp0,eetawstmp0);
+
+                  if(gmrapidtmp0<0.5 && eetatmp0<0.5 ) fHistComm[iq][0].fPtCorrBinein->Fill(grandMa->Pt(),mcpart->Pt());
+                  else if(gmrapidtmp0<0.5 && eetatmp0>0.5 ) fHistComm[iq][0].fPtCorrBineout->Fill(grandMa->Pt(),mcpart->Pt());
+                  else if(gmrapidtmp0>0.5 && eetatmp0<0.5 ) fHistComm[iq][0].fPtCorrBoutein->Fill(grandMa->Pt(),mcpart->Pt());
+                  else if(gmrapidtmp0>0.5 && eetatmp0>0.5 ) fHistComm[iq][0].fPtCorrBouteout->Fill(grandMa->Pt(),mcpart->Pt());
+                  //======================================================================================
+
                   // ratio between pT of electron and pT of mother B hadron 
                   if(grandMa->Pt()) {
                     fHistComm[iq][0].fDePtRatio->Fill(grandMa->Pt(),mcpart->Pt()/grandMa->Pt());
@@ -1089,6 +1189,62 @@ void AliHFEmcQA::GetDecayedKine(TParticle* mcpart, const Int_t kquark, Int_t kde
                 }
               }
 
+              //mj: to calculate D to e eta correlation to calculate total heavy quark cross section
+              Int_t kLabel = partMotherCopy->GetFirstMother();
+              Bool_t isGrandmaYes = kFALSE;
+              Double_t gmrapidwstmp =0;
+              if (!(kLabel < 0)){ // safety protection
+                if((mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(kLabel))))){ 
+                  TParticle* grandMatmp = mctrack->Particle();
+                  Int_t grandMaPDGtmp = grandMatmp->GetPdgCode();
+                  if ( int(abs(grandMaPDGtmp)/100.) == kCharm || int(abs(grandMaPDGtmp)/1000.) == kCharm ) isGrandmaYes = kTRUE;
+                  if ( int(abs(grandMaPDGtmp)/100.) == kBeauty || int(abs(grandMaPDGtmp)/1000.) == kBeauty) isGrandmaYes = kTRUE;
+                  gmrapidwstmp = AliHFEtools::GetRapidity(grandMatmp);
+                }
+              }
+
+              Double_t mrapidwstmp = AliHFEtools::GetRapidity(partMotherCopy);
+              Double_t eetawstmp = mcpart->Eta();
+
+              Double_t mrapidtmp = TMath::Abs(mrapidwstmp);
+              Double_t eetatmp = TMath::Abs(eetawstmp);
+
+              fHistComm[iq][0].fEtaCorrD->Fill(mrapidwstmp,eetawstmp);
+              if(isGrandmaYes) fHistComm[iq][0].fEtaCorrGD->Fill(gmrapidwstmp,eetawstmp);
+              else fHistComm[iq][0].fEtaCorrGD->Fill(mrapidwstmp,eetawstmp);
+
+              if(mrapidtmp<0.5 && eetatmp<0.5 ) fHistComm[iq][0].fPtCorrDinein->Fill(partMotherCopy->Pt(),mcpart->Pt());
+              else if(mrapidtmp<0.5 && eetatmp>0.5 ) fHistComm[iq][0].fPtCorrDineout->Fill(partMotherCopy->Pt(),mcpart->Pt());
+              else if(mrapidtmp>0.5 && eetatmp<0.5 ) fHistComm[iq][0].fPtCorrDoutein->Fill(partMotherCopy->Pt(),mcpart->Pt());
+              else if(mrapidtmp>0.5 && eetatmp>0.5 ) fHistComm[iq][0].fPtCorrDouteout->Fill(partMotherCopy->Pt(),mcpart->Pt());
+              if(TMath::Abs(partMotherCopy->GetPdgCode())==411) {
+                fHistComm[iq][0].fEtaCorrDp->Fill(mrapidwstmp,eetawstmp);
+                if(isGrandmaYes) fHistComm[iq][0].fEtaCorrGDp->Fill(gmrapidwstmp,eetawstmp);
+                else fHistComm[iq][0].fEtaCorrGDp->Fill(mrapidwstmp,eetawstmp);
+                if(mrapidtmp<0.5 && eetatmp<0.5 ) fHistComm[iq][0].fPtCorrDpDinein->Fill(partMotherCopy->Pt(),mcpart->Pt());
+                else if(mrapidtmp<0.5 && eetatmp>0.5 ) fHistComm[iq][0].fPtCorrDpDineout->Fill(partMotherCopy->Pt(),mcpart->Pt());
+                else if(mrapidtmp>0.5 && eetatmp<0.5 ) fHistComm[iq][0].fPtCorrDpDoutein->Fill(partMotherCopy->Pt(),mcpart->Pt());
+                else if(mrapidtmp>0.5 && eetatmp>0.5 ) fHistComm[iq][0].fPtCorrDpDouteout->Fill(partMotherCopy->Pt(),mcpart->Pt());
+              }
+              else if(TMath::Abs(partMotherCopy->GetPdgCode())==421) {
+                fHistComm[iq][0].fEtaCorrD0->Fill(mrapidwstmp,eetawstmp);
+                if(isGrandmaYes) fHistComm[iq][0].fEtaCorrGD0->Fill(gmrapidwstmp,eetawstmp);
+                else fHistComm[iq][0].fEtaCorrGD0->Fill(mrapidwstmp,eetawstmp);
+                if(mrapidtmp<0.5 && eetatmp<0.5 ) fHistComm[iq][0].fPtCorrD0Dinein->Fill(partMotherCopy->Pt(),mcpart->Pt());
+                else if(mrapidtmp<0.5 && eetatmp>0.5 ) fHistComm[iq][0].fPtCorrD0Dineout->Fill(partMotherCopy->Pt(),mcpart->Pt());
+                else if(mrapidtmp>0.5 && eetatmp<0.5 ) fHistComm[iq][0].fPtCorrD0Doutein->Fill(partMotherCopy->Pt(),mcpart->Pt());
+                else if(mrapidtmp>0.5 && eetatmp>0.5 ) fHistComm[iq][0].fPtCorrD0Douteout->Fill(partMotherCopy->Pt(),mcpart->Pt());
+              }
+              else {
+                fHistComm[iq][0].fEtaCorrDrest->Fill(mrapidwstmp,eetawstmp);
+                if(isGrandmaYes) fHistComm[iq][0].fEtaCorrGDrest->Fill(gmrapidwstmp,eetawstmp);
+                else fHistComm[iq][0].fEtaCorrGDrest->Fill(mrapidwstmp,eetawstmp);
+                if(mrapidtmp<0.5 && eetatmp<0.5 ) fHistComm[iq][0].fPtCorrDrestDinein->Fill(partMotherCopy->Pt(),mcpart->Pt());
+                else if(mrapidtmp<0.5 && eetatmp>0.5 ) fHistComm[iq][0].fPtCorrDrestDineout->Fill(partMotherCopy->Pt(),mcpart->Pt());
+                else if(mrapidtmp>0.5 && eetatmp<0.5 ) fHistComm[iq][0].fPtCorrDrestDoutein->Fill(partMotherCopy->Pt(),mcpart->Pt());
+                else if(mrapidtmp>0.5 && eetatmp>0.5 ) fHistComm[iq][0].fPtCorrDrestDouteout->Fill(partMotherCopy->Pt(),mcpart->Pt());
+              }
+
               // distance between electron production point and primary vertex
               fHistComm[iq][0].feDistance->Fill(partMotherCopy->Pt(),decayLxy);
               if(eabsEta<0.9){
@@ -1563,16 +1719,19 @@ Int_t AliHFEmcQA::GetElecSource(TParticle * const mcpart)
   TParticle *partMother = mctrack->Particle();
   TParticle *partMotherCopy = mctrack->Particle();
   Int_t maPdgcode = partMother->GetPdgCode();
+  Int_t grmaPdgcode;
+  Int_t ggrmaPdgcode;
 
    // if the mother is charmed hadron  
 
    if(abs(maPdgcode)==443){ // J/spi
       Int_t jLabel = partMother->GetFirstMother();
-      if(!(mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(jLabel))))) return kJpsi; 
-      TParticle* grandMa = mctrack->Particle();
-      Int_t grandMaPDG = grandMa->GetPdgCode();
-      if((int(abs(grandMaPDG)/100.)%10) == kBeauty || (int(abs(grandMaPDG)/1000.)%10) == kBeauty) return kB2Jpsi;
-      else return -1;   
+      if((mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(jLabel))))){
+        TParticle* grandMa = mctrack->Particle();
+        Int_t grandMaPDG = grandMa->GetPdgCode();
+        if((int(abs(grandMaPDG)/100.)%10) == kBeauty || (int(abs(grandMaPDG)/1000.)%10) == kBeauty) return kB2Jpsi;
+      }
+      return kJpsi;   
    } 
    else if ( (int(abs(maPdgcode)/100.)%10) == kCharm || (int(abs(maPdgcode)/1000.)%10) == kCharm ) {
 
@@ -1622,6 +1781,27 @@ Int_t AliHFEmcQA::GetElecSource(TParticle * const mcpart)
      if(!(mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(tmpMomLabel))))) return -1;
      partMother = mctrack->Particle();
      maPdgcode = partMother->GetPdgCode();
+
+     // check if the ligth meson is the decay product of heavy mesons
+     tmpMomLabel = partMother->GetFirstMother();
+     if((mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(tmpMomLabel))))) {
+      partMother = mctrack->Particle();
+      grmaPdgcode = partMother->GetPdgCode();
+
+      if ( (int(abs(grmaPdgcode)/100.)%10) == kBeauty || (int(abs(grmaPdgcode)/1000.)%10) == kBeauty ) return kGammaB2M;
+      if ( (int(abs(grmaPdgcode)/100.)%10) == kCharm || (int(abs(grmaPdgcode)/1000.)%10) == kCharm ) return kGammaD2M;
+      if ( abs(grmaPdgcode) == 221 ) return kElse; //mj to remove secondary pi0 decay electrons from eta decays, mainly to eta signal enhance samples
+
+      tmpMomLabel = partMother->GetFirstMother();
+      if((mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(tmpMomLabel))))) {
+       partMother = mctrack->Particle();
+       ggrmaPdgcode = partMother->GetPdgCode();
+
+       if ( (int(abs(ggrmaPdgcode)/100.)%10) == kBeauty || (int(abs(ggrmaPdgcode)/1000.)%10) == kBeauty ) return kGammaB2M;
+       if ( (int(abs(ggrmaPdgcode)/100.)%10) == kCharm || (int(abs(ggrmaPdgcode)/1000.)%10) == kCharm ) return kGammaD2M;
+      }
+     }
+
      if ( abs(maPdgcode) == 111 ) {
        return kGammaPi0;
      } 
@@ -1644,29 +1824,53 @@ Int_t AliHFEmcQA::GetElecSource(TParticle * const mcpart)
      return origin;
 
    } 
-   else if ( abs(maPdgcode) == 111 ) {
-     return kPi0;
-   } 
-   else if ( abs(maPdgcode) == 221 ) {
-     return kEta;
-   } 
-   else if ( abs(maPdgcode) == 223 ) {
-     return kOmega;
-   } 
-   else if ( abs(maPdgcode) == 333 ) {
-     return kPhi;
-   } 
-   else if ( abs(maPdgcode) == 331 ) {
-     return kEtaPrime;
-   } 
-   else if ( abs(maPdgcode) == 113 ) {
-     return kRho0;
-   } 
-   else if ( abs(maPdgcode) == 321 || abs(maPdgcode) == 130 ) {
-     return kKe3;
-   }
-   else{ 
-    origin = kElse;
+   else {
+
+     // check if the ligth meson is the decay product of heavy mesons
+     tmpMomLabel = partMotherCopy->GetFirstMother();
+     if((mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(tmpMomLabel))))) {
+      partMother = mctrack->Particle();
+      grmaPdgcode = partMother->GetPdgCode();
+
+      if ( (int(abs(grmaPdgcode)/100.)%10) == kBeauty || (int(abs(grmaPdgcode)/1000.)%10) == kBeauty ) return kGammaB2M;
+      if ( (int(abs(grmaPdgcode)/100.)%10) == kCharm || (int(abs(grmaPdgcode)/1000.)%10) == kCharm ) return kGammaD2M;
+      if ( abs(grmaPdgcode) == 221 ) return kElse; //mj to remove secondary pi0 decay electrons from eta decays, mainly to eta signal enhance samples
+
+      tmpMomLabel = partMother->GetFirstMother();
+      if((mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(tmpMomLabel))))) {
+       partMother = mctrack->Particle();
+       ggrmaPdgcode = partMother->GetPdgCode();
+
+       if ( (int(abs(ggrmaPdgcode)/100.)%10) == kBeauty || (int(abs(ggrmaPdgcode)/1000.)%10) == kBeauty ) return kGammaB2M;
+       if ( (int(abs(ggrmaPdgcode)/100.)%10) == kCharm || (int(abs(ggrmaPdgcode)/1000.)%10) == kCharm ) return kGammaD2M;
+      }
+     }
+
+     if ( abs(maPdgcode) == 111 ) {
+       return kPi0;
+     } 
+     else if ( abs(maPdgcode) == 221 ) {
+       return kEta;
+     } 
+     else if ( abs(maPdgcode) == 223 ) {
+       return kOmega;
+     } 
+     else if ( abs(maPdgcode) == 333 ) {
+       return kPhi;
+     } 
+     else if ( abs(maPdgcode) == 331 ) {
+       return kEtaPrime;
+     } 
+     else if ( abs(maPdgcode) == 113 ) {
+       return kRho0;
+     } 
+     else if ( abs(maPdgcode) == 321 || abs(maPdgcode) == 130 ) {
+       return kKe3;
+     }
+     else{ 
+      origin = kElse;
+     }
+
    }
    return origin;
 }
@@ -1914,6 +2118,41 @@ void AliHFEmcQA::AliHistsComm::FillList(TList *l) const {
   if(fPtCorrDp) l->Add(fPtCorrDp);
   if(fPtCorrD0) l->Add(fPtCorrD0);
   if(fPtCorrDrest) l->Add(fPtCorrDrest);
+
+  if(fPtCorrDinein) l->Add(fPtCorrDinein);
+  if(fPtCorrDineout) l->Add(fPtCorrDineout);
+  if(fPtCorrDoutein) l->Add(fPtCorrDoutein);
+  if(fPtCorrDouteout) l->Add(fPtCorrDouteout);
+  if(fPtCorrDpDinein) l->Add(fPtCorrDpDinein);
+  if(fPtCorrDpDineout) l->Add(fPtCorrDpDineout);
+  if(fPtCorrDpDoutein) l->Add(fPtCorrDpDoutein);
+  if(fPtCorrDpDouteout) l->Add(fPtCorrDpDouteout);
+  if(fPtCorrD0Dinein) l->Add(fPtCorrD0Dinein);
+  if(fPtCorrD0Dineout) l->Add(fPtCorrD0Dineout);
+  if(fPtCorrD0Doutein) l->Add(fPtCorrD0Doutein);
+  if(fPtCorrD0Douteout) l->Add(fPtCorrD0Douteout);
+  if(fPtCorrDrestDinein) l->Add(fPtCorrDrestDinein);
+  if(fPtCorrDrestDineout) l->Add(fPtCorrDrestDineout);
+  if(fPtCorrDrestDoutein) l->Add(fPtCorrDrestDoutein);
+  if(fPtCorrDrestDouteout) l->Add(fPtCorrDrestDouteout);
+
+  if(fEtaCorrD) l->Add(fEtaCorrD);
+  if(fEtaCorrDp) l->Add(fEtaCorrDp);
+  if(fEtaCorrD0) l->Add(fEtaCorrD0);
+  if(fEtaCorrDrest) l->Add(fEtaCorrDrest);
+
+  if(fEtaCorrGD) l->Add(fEtaCorrGD);
+  if(fEtaCorrGDp) l->Add(fEtaCorrGDp);
+  if(fEtaCorrGD0) l->Add(fEtaCorrGD0);
+  if(fEtaCorrGDrest) l->Add(fEtaCorrGDrest);
+
+  if(fEtaCorrB) l->Add(fEtaCorrB);
+  if(fEtaCorrGB) l->Add(fEtaCorrGB);
+  if(fPtCorrBinein) l->Add(fPtCorrBinein);
+  if(fPtCorrBineout) l->Add(fPtCorrBineout);
+  if(fPtCorrBoutein) l->Add(fPtCorrBoutein);
+  if(fPtCorrBouteout) l->Add(fPtCorrBouteout);
+
   if(fDePtRatio) l->Add(fDePtRatio);
   if(feDistance) l->Add(feDistance);
   if(fDeDistance) l->Add(fDeDistance);
index 699a522..1457c4d 100644 (file)
@@ -48,7 +48,7 @@ class AliHFEmcQA: public TObject {
   public: 
     enum heavyType {kCharm=4, kBeauty=5, kOthers=6, kElectronPDG=11};
     enum qType {kQuark, kantiQuark, kHadron, keHadron, kDeHadron, kElectron, kElectron2nd};
-    enum SourceType {kDirectCharm=1, kDirectBeauty=2, kBeautyCharm=3, kGamma=4, kPi0=5, kElse=6, kMisID=7, kEta=8, kOmega=9, kPhi=10, kEtaPrime=11, kRho0=12, kGammaPi0=13, kGammaEta=14, kGammaOmega=15, kGammaPhi=16, kGammaEtaPrime=17, kGammaRho0=18, kJpsi=19, kB2Jpsi=20, kKe3=21};
+    enum SourceType {kDirectCharm=1, kDirectBeauty=2, kBeautyCharm=3, kGamma=4, kPi0=5, kElse=6, kMisID=7, kEta=8, kOmega=9, kPhi=10, kEtaPrime=11, kRho0=12, kGammaPi0=13, kGammaEta=14, kGammaOmega=15, kGammaPhi=16, kGammaEtaPrime=17, kGammaRho0=18, kJpsi=19, kB2Jpsi=20, kKe3=21, kGammaB2M=22, kGammaD2M=23};
     enum ProcessType {
       kPairCreationFromq,  kPairCreationFromg,  kFlavourExitation,  kGluonSplitting, kInitialPartonShower, kLightQuarkShower
     };
@@ -162,6 +162,39 @@ class AliHFEmcQA: public TObject {
       TH2F *feDistance; // distance between electron production point to mother particle 
       TH2F *fDeDistance; // distance between D electron production point to mother particle
 
+      TH2F *fPtCorrDinein; // pt correlation between e and direct D or B 
+      TH2F *fPtCorrDineout; // pt correlation between e and direct D or B 
+      TH2F *fPtCorrDoutein; // pt correlation between e and direct D or B 
+      TH2F *fPtCorrDouteout; // pt correlation between e and direct D or B 
+      TH2F *fPtCorrDpDinein; // pt correlation between e and direct D+
+      TH2F *fPtCorrDpDineout; // pt correlation between e and direct D+
+      TH2F *fPtCorrDpDoutein; // pt correlation between e and direct D+
+      TH2F *fPtCorrDpDouteout; // pt correlation between e and direct D+
+      TH2F *fPtCorrD0Dinein; // pt correlation between e and direct D0
+      TH2F *fPtCorrD0Dineout; // pt correlation between e and direct D0
+      TH2F *fPtCorrD0Doutein; // pt correlation between e and direct D0
+      TH2F *fPtCorrD0Douteout; // pt correlation between e and direct D0
+      TH2F *fPtCorrDrestDinein; // pt correlation between e and direct D rest
+      TH2F *fPtCorrDrestDineout; // pt correlation between e and direct D rest
+      TH2F *fPtCorrDrestDoutein; // pt correlation between e and direct D rest
+      TH2F *fPtCorrDrestDouteout; // pt correlation between e and direct D rest
+
+      TH2F *fEtaCorrD; // eta correlation between e and direct D 
+      TH2F *fEtaCorrDp; // eta correlation between e and direct D 
+      TH2F *fEtaCorrD0; // eta correlation between e and direct D 
+      TH2F *fEtaCorrDrest; // eta correlation between e and direct D 
+      TH2F *fEtaCorrGD; // eta correlation between e and direct D 
+      TH2F *fEtaCorrGDp; // eta correlation between e and direct D 
+      TH2F *fEtaCorrGD0; // eta correlation between e and direct D 
+      TH2F *fEtaCorrGDrest; // eta correlation between e and direct D 
+
+      TH2F *fEtaCorrB; // eta correlation between e and B
+      TH2F *fEtaCorrGB; // eta correlation between e and B
+      TH2F *fPtCorrBinein; // eta correlation between e and B
+      TH2F *fPtCorrBineout; // eta correlation between e and B
+      TH2F *fPtCorrBoutein; // eta correlation between e and B
+      TH2F *fPtCorrBouteout; // eta correlation between e and B
+
                        AliHistsComm()
                          : fNq()
                          , fProcessID()
@@ -173,6 +206,39 @@ class AliHFEmcQA: public TObject {
                          , fDePtRatio()
                          , feDistance()
                          , fDeDistance()
+
+                          , fPtCorrDinein()
+                          , fPtCorrDineout()
+                          , fPtCorrDoutein()
+                          , fPtCorrDouteout()
+                          , fPtCorrDpDinein()
+                          , fPtCorrDpDineout()
+                          , fPtCorrDpDoutein()
+                          , fPtCorrDpDouteout()
+                          , fPtCorrD0Dinein()
+                          , fPtCorrD0Dineout()
+                          , fPtCorrD0Doutein()
+                          , fPtCorrD0Douteout()
+                          , fPtCorrDrestDinein()
+                          , fPtCorrDrestDineout()
+                          , fPtCorrDrestDoutein()
+                          , fPtCorrDrestDouteout()
+
+                          , fEtaCorrD()
+                          , fEtaCorrDp()
+                          , fEtaCorrD0()
+                          , fEtaCorrDrest()
+                          , fEtaCorrGD()
+                          , fEtaCorrGDp()
+                          , fEtaCorrGD0()
+                          , fEtaCorrGDrest()
+
+                          , fEtaCorrB()
+                          , fEtaCorrGB()
+                          , fPtCorrBinein()
+                          , fPtCorrBineout()
+                          , fPtCorrBoutein()
+                          , fPtCorrBouteout()
       {  
                          // default constructor
                        };
@@ -187,6 +253,39 @@ class AliHFEmcQA: public TObject {
                          , fDePtRatio(p.fDePtRatio)
                          , feDistance(p.feDistance)
                          , fDeDistance(p.fDeDistance)
+
+                          , fPtCorrDinein(p.fPtCorrDinein)
+                          , fPtCorrDineout(p.fPtCorrDineout)
+                          , fPtCorrDoutein(p.fPtCorrDoutein)
+                          , fPtCorrDouteout(p.fPtCorrDouteout)
+                          , fPtCorrDpDinein(p.fPtCorrDpDinein)
+                          , fPtCorrDpDineout(p.fPtCorrDpDineout)
+                          , fPtCorrDpDoutein(p.fPtCorrDpDoutein)
+                          , fPtCorrDpDouteout(p.fPtCorrDpDouteout)
+                          , fPtCorrD0Dinein(p.fPtCorrD0Dinein)
+                          , fPtCorrD0Dineout(p.fPtCorrD0Dineout)
+                          , fPtCorrD0Doutein(p.fPtCorrD0Doutein)
+                          , fPtCorrD0Douteout(p.fPtCorrD0Douteout)
+                          , fPtCorrDrestDinein(p.fPtCorrDrestDinein)
+                          , fPtCorrDrestDineout(p.fPtCorrDrestDineout)
+                          , fPtCorrDrestDoutein(p.fPtCorrDrestDoutein)
+                          , fPtCorrDrestDouteout(p.fPtCorrDrestDouteout)
+
+                          , fEtaCorrD(p.fEtaCorrD)
+                          , fEtaCorrDp(p.fEtaCorrDp)
+                          , fEtaCorrD0(p.fEtaCorrD0)
+                          , fEtaCorrDrest(p.fEtaCorrDrest)
+                          , fEtaCorrGD(p.fEtaCorrGD)
+                          , fEtaCorrGDp(p.fEtaCorrGDp)
+                          , fEtaCorrGD0(p.fEtaCorrGD0)
+                          , fEtaCorrGDrest(p.fEtaCorrGDrest)
+
+                          , fEtaCorrB(p.fEtaCorrB)
+                          , fEtaCorrGB(p.fEtaCorrGB)
+                          , fPtCorrBinein(p.fPtCorrBinein)
+                          , fPtCorrBineout(p.fPtCorrBineout)
+                          , fPtCorrBoutein(p.fPtCorrBoutein)
+                          , fPtCorrBouteout(p.fPtCorrBouteout)
       {
                          // copy constructor
                        };
index 2dd3b52..f8678bf 100644 (file)
@@ -28,6 +28,7 @@
 #include <TF1.h>
 #include <TMath.h>
 
+#include "AliTPCdEdxInfo.h"
 #include "AliAODPid.h"
 #include "AliAODTrack.h"
 #include "AliAODMCParticle.h"
@@ -50,6 +51,7 @@ AliHFEpidTPC::AliHFEpidTPC() :
   , fLineCrossingsEnabled(0)
   , fkEtaCorrection(NULL)
   , fHasCutModel(kFALSE)
+  , fUseOnlyOROC(kFALSE)
   , fNsigmaTPC(3)
   , fRejectionEnabled(0)
 {
@@ -74,6 +76,7 @@ AliHFEpidTPC::AliHFEpidTPC(const char* name) :
   , fLineCrossingsEnabled(0)
   , fkEtaCorrection(NULL)
   , fHasCutModel(kFALSE)
+  , fUseOnlyOROC(kFALSE)
   , fNsigmaTPC(3)
   , fRejectionEnabled(0)
 {
@@ -96,6 +99,7 @@ AliHFEpidTPC::AliHFEpidTPC(const AliHFEpidTPC &ref) :
   , fLineCrossingsEnabled(0)
   , fkEtaCorrection(NULL)
   , fHasCutModel(ref.fHasCutModel)
+  , fUseOnlyOROC(ref.fUseOnlyOROC)
   , fNsigmaTPC(2)
   , fRejectionEnabled(0)
 {
@@ -126,6 +130,7 @@ void AliHFEpidTPC::Copy(TObject &o) const{
   target.fkEtaCorrection =fkEtaCorrection;
   target.fLineCrossingsEnabled = fLineCrossingsEnabled;
   target.fHasCutModel = fHasCutModel;
+  target.fUseOnlyOROC = fUseOnlyOROC;
   target.fNsigmaTPC = fNsigmaTPC;
   target.fRejectionEnabled = fRejectionEnabled;
 
@@ -173,7 +178,20 @@ Int_t AliHFEpidTPC::IsSelected(const AliHFEpidObject *track, AliHFEpidQAmanager
   const AliVTrack *rectrack;
   AliESDtrack esdtrack;
   AliAODTrack aodtrack;
-  if(fkEtaCorrection){
+  if(fUseOnlyOROC && !fkEtaCorrection) {
+    if(track->IsESDanalysis()){
+      esdtrack.~AliESDtrack();
+      new(&esdtrack) AliESDtrack(*(static_cast<const AliESDtrack *>(track->GetRecTrack())));
+      UseOROC(&esdtrack, anatype);
+      rectrack = &esdtrack;
+    } else {
+      aodtrack.~AliAODTrack();
+      new(&aodtrack) AliAODTrack(*(static_cast<const AliAODTrack *>(track->GetRecTrack())));
+      UseOROC(&aodtrack, anatype);
+      rectrack = &aodtrack;
+    }
+  }
+  else if(fkEtaCorrection){
     // Correction available
     // apply it on copy
     if(track->IsESDanalysis()){
@@ -300,7 +318,35 @@ void AliHFEpidTPC::ApplyEtaCorrection(AliVTrack *track, AliHFEpidObject::Analysi
     if(pid) pid->SetTPCsignal(original);
   }
 }
+//___________________________________________________________________
+void AliHFEpidTPC::UseOROC(AliVTrack *track, AliHFEpidObject::AnalysisType_t anatype) const{
+  //
+  // Use TPC signal from the OROC
+  // N.B. This correction has to be applied on a copy track
+  //
+  //Double_t original = track->GetTPCsignal();
+  
+  if(anatype == AliHFEpidObject::kESDanalysis){
+    AliESDtrack *esdtrack = static_cast<AliESDtrack *>(track);
+    AliTPCdEdxInfo *dEdxInfo = track->GetTPCdEdxInfo();
+    Double32_t  TPCsignalRegion[4]; // TPC dEdx signal in 4 different regions - 0 - IROC, 1- OROC medium, 2 - OROC long, 3- OROC all, (default truncation used)
+    Char_t      TPCsignalNRegion[3]; // number of clusters above threshold used in the dEdx calculation
+    Char_t      TPCsignalNRowRegion[3]; // number of crosed rows used in the dEdx calculation - signal below threshold included
+    dEdxInfo->GetTPCSignalRegionInfo(TPCsignalRegion,TPCsignalNRegion,TPCsignalNRowRegion);
+    esdtrack->SetTPCsignal(TPCsignalRegion[3],esdtrack->GetTPCsignalSigma(),(TPCsignalNRegion[1]+TPCsignalNRegion[2])); // the two last are not ok
+  } else {
+    AliAODTrack *aodtrack = static_cast<AliAODTrack *>(track);
+    AliTPCdEdxInfo *dEdxInfo = track->GetTPCdEdxInfo();
+    Double32_t  TPCsignalRegion[4]; // TPC dEdx signal in 4 different regions - 0 - IROC, 1- OROC medium, 2 - OROC long, 3- OROC all, (default truncation used)
+    Char_t      TPCsignalNRegion[3]; // number of clusters above threshold used in the dEdx calculation
+    Char_t      TPCsignalNRowRegion[3]; // number of crosed rows used in the dEdx calculation - signal below threshold included
+    dEdxInfo->GetTPCSignalRegionInfo(TPCsignalRegion,TPCsignalNRegion,TPCsignalNRowRegion);
+    AliAODPid *pid = aodtrack->GetDetPid();
+    if(pid) pid->SetTPCsignal(TPCsignalRegion[3]);
+    if(pid) pid->SetTPCsignalN((TPCsignalNRegion[1]+TPCsignalNRegion[2]));
+  }
 
+}
 //___________________________________________________________________
 void AliHFEpidTPC::AddTPCdEdxLineCrossing(Int_t species, Double_t sigma){
   //
index 1e56687..69de5a1 100644 (file)
@@ -52,6 +52,7 @@ class AliHFEpidTPC : public AliHFEpidBase{
     Bool_t HasAsymmetricSigmaCut() const { return TestBit(kAsymmetricSigmaCut);}
     Bool_t HasParticleRejection() const { return TestBit(kRejection); }
     void SetTPCnSigma(Short_t nSigma) { fNsigmaTPC = nSigma; };
+    void SetUseOnlyOROC(Bool_t useOnlyOROC) { fUseOnlyOROC = useOnlyOROC; };
     inline void SetAsymmetricTPCsigmaCut(Float_t pmin, Float_t pmax, Float_t sigmaMin, Float_t sigmaMax);
     inline void SetRejectParticle(Int_t species, Float_t pmin, Float_t sigmaMin, Float_t pmax, Float_t sigmaMax);
 
@@ -64,6 +65,7 @@ class AliHFEpidTPC : public AliHFEpidBase{
 
     Double_t GetP(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType) const;
     void ApplyEtaCorrection(AliVTrack *track, AliHFEpidObject::AnalysisType_t anatype) const;
+    void UseOROC(AliVTrack *track, AliHFEpidObject::AnalysisType_t anatype) const;
 
   protected:
     void Copy(TObject &o) const;
@@ -82,6 +84,7 @@ class AliHFEpidTPC : public AliHFEpidBase{
     const TF1 *fkLowerSigmaCut[12];                         // Lower Sigma Cut
     const TF1 *fkEtaCorrection;                             // Correction for the eta dependence
     Bool_t fHasCutModel;                                    // Has cut model functions
+    Bool_t fUseOnlyOROC;                                    // Use only OROC
     Float_t fPAsigCut[2];                                   // Momentum region where to perform asymmetric sigma cut
     Float_t fNAsigmaTPC[2];                                 // Asymmetric TPC Sigma band        
     Short_t fNsigmaTPC;                                     // TPC sigma band
index 3f64c8e..4f032a4 100644 (file)
@@ -94,14 +94,17 @@ AliHFEspectrum::AliHFEspectrum(const char *name):
   fNCentralityBinAtTheEnd(0),
   fTestCentralityLow(-1),
   fTestCentralityHigh(-1),
+  fFillMoreCorrelationMatrix(kFALSE),
   fHadronEffbyIPcut(NULL),
   fConversionEffbgc(NULL),
   fNonHFEEffbgc(NULL),      
   fBSpectrum2ndMethod(NULL),
   fkBeauty2ndMethodfilename(""),
   fBeamType(0),
+  fEtaSyst(kTRUE),
   fDebugLevel(0),
-  fWriteToFile(kFALSE)
+  fWriteToFile(kFALSE),
+  fUnfoldBG(kFALSE)
 {
   //
   // Default constructor
@@ -162,7 +165,7 @@ Bool_t AliHFEspectrum::Init(const AliHFEcontainer *datahfecontainer, const AliHF
   // and the appropriate correlation matrix
   //
 
-
+  
   if(fBeauty2ndMethod) CallInputFileForBeauty2ndMethod();
 
   Int_t kNdim = 3;
@@ -269,19 +272,20 @@ Bool_t AliHFEspectrum::Init(const AliHFEcontainer *datahfecontainer, const AliHF
              if(fBeamType==1)
              {
               
-               fConvSourceContainer[iSource][iLevel][icentr] = GetSlicedContainer(convtempContainer, fNbDimensions, dims, -1, fChargeChoosen,icentr+1,icentr+1);
-               fNonHFESourceContainer[iSource][iLevel][icentr] = GetSlicedContainer(nonHFEtempContainer, fNbDimensions, dims, -1, fChargeChoosen,icentr+1,icentr+1);
+               fConvSourceContainer[iSource][iLevel][icentr] = GetSlicedContainer(convtempContainer, fNbDimensions, dims, -1, fChargeChoosen,icentr,icentr);
+               fNonHFESourceContainer[iSource][iLevel][icentr] = GetSlicedContainer(nonHFEtempContainer, fNbDimensions, dims, -1, fChargeChoosen,icentr,icentr);
              }
 //           if((!fConvSourceContainer[iSource][iLevel][icentr])||(!fNonHFESourceContainer[iSource][iLevel])) return kFALSE;
          }
+          if(fBeamType == 1)break;
        }
       }
     }
-    else{      
+    // else{      
       nonHFEweightedContainer = bghfecontainer->GetCFContainer("mesonElecs");
       convweightedContainer = bghfecontainer->GetCFContainer("conversionElecs");
       if((!convweightedContainer)||(!nonHFEweightedContainer)) return kFALSE;  
-    }
+      //}
   }
   if((!mccontaineresd) || (!mccontainermc)) return kFALSE;  
   
@@ -299,21 +303,21 @@ Bool_t AliHFEspectrum::Init(const AliHFEcontainer *datahfecontainer, const AliHF
    mccontainermcD = GetSlicedContainer(mccontainermcbg, fNbDimensions, dims, source, fChargeChoosen);
    SetContainer(mccontainermcD,AliHFEspectrum::kMCContainerCharmMC);
 
-   if(!fNonHFEsyst){
+   //if(!fNonHFEsyst){
      AliCFContainer *nonHFEweightedContainerD = GetSlicedContainer(nonHFEweightedContainer, fNbDimensions, dims, -1, fChargeChoosen);
      SetContainer(nonHFEweightedContainerD,AliHFEspectrum::kMCWeightedContainerNonHFEESD);
      AliCFContainer *convweightedContainerD = GetSlicedContainer(convweightedContainer, fNbDimensions, dims, -1, fChargeChoosen);
      SetContainer(convweightedContainerD,AliHFEspectrum::kMCWeightedContainerConversionESD);
-   }
+     //}
 
-   SetParameterizedEff(mccontainermc, mccontainermcbg, mccontaineresd, mccontaineresdbg, dims);
+     SetParameterizedEff(mccontainermc, mccontainermcbg, mccontaineresd, mccontaineresdbg, dims);
 
   }
   // MC container: correlation matrix
   THnSparseF *mccorrelation = 0x0;
   if(fInclusiveSpectrum) {
-    if(fStepMC==(AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kStepHFEcutsTRD + 2)) mccorrelation = mchfecontainer->GetCorrelationMatrix("correlationstepafterPID");
-    else if(fStepMC==(AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kStepHFEcutsTRD + 1)) mccorrelation = mchfecontainer->GetCorrelationMatrix("correlationstepafterPID");
+    if(fStepMC==(AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kStepHFEcutsTRD + 2)) mccorrelation = mchfecontainer->GetCorrelationMatrix("correlationstepbeforePID");
+    else if(fStepMC==(AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kStepHFEcutsTRD + 1)) mccorrelation = mchfecontainer->GetCorrelationMatrix("correlationstepbeforePID");
     else if(fStepMC==(AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kStepHFEcutsTRD)) mccorrelation = mchfecontainer->GetCorrelationMatrix("correlationstepbeforePID");
     else if(fStepMC==(AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kStepHFEcutsTRD - 1)) mccorrelation = mchfecontainer->GetCorrelationMatrix("correlationstepbeforePID");
     else mccorrelation = mchfecontainer->GetCorrelationMatrix("correlationstepafterPID");
@@ -323,7 +327,13 @@ Bool_t AliHFEspectrum::Init(const AliHFEcontainer *datahfecontainer, const AliHF
   else mccorrelation = mchfecontainer->GetCorrelationMatrix("correlationstepafterPID"); // we confirmed that we get same result by using it instead of correlationstepafterDE
   //else mccorrelation = mchfecontainer->GetCorrelationMatrix("correlationstepafterDE");
   if(!mccorrelation) return kFALSE;
-  THnSparseF *mccorrelationD = GetSlicedCorrelation(mccorrelation, fNbDimensions, dims,fTestCentralityLow,fTestCentralityHigh);
+  Int_t testCentralityLow = fTestCentralityLow;
+  Int_t testCentralityHigh = fTestCentralityHigh;
+  if(fFillMoreCorrelationMatrix) {
+    testCentralityLow = fTestCentralityLow-1;
+    testCentralityHigh = fTestCentralityHigh+1;
+  }
+  THnSparseF *mccorrelationD = GetSlicedCorrelation(mccorrelation, fNbDimensions, dims,testCentralityLow,testCentralityHigh);
   if(!mccorrelationD) {
     printf("No correlation\n");
     return kFALSE;
@@ -1574,6 +1584,8 @@ AliCFDataGrid* AliHFEspectrum::GetCharmBackground(){
   delete[] nBinPbPb;
   delete[] binsPbPb;
 
+  if(fUnfoldBG) UnfoldBG(charmBackgroundGrid);
+
   return charmBackgroundGrid;
 }
 
@@ -2318,7 +2330,7 @@ TGraphErrors *AliHFEspectrum::Normalize(THnSparse * const spectrum,Int_t i) cons
   // Normalize the spectrum to 1/(2*Pi*p_{T})*dN/dp_{T} (GeV/c)^{-2}
   // Give the final pt spectrum to be compared
   //
+
   if(fNEvents[i] > 0) {
 
     Int_t ptpr = 0;
@@ -2793,8 +2805,8 @@ void AliHFEspectrum::SetParameterizedEff(AliCFContainer *container, AliCFContain
      loopcentr=nCentralitybinning;
    }
 
-   TF1 *fittofpid = new TF1("fittofpid","[0]*([1]+[2]*log(x)+[3]*log(x)*log(x))*tanh([4]*x-[5])",0.5,8.);
-   TF1 *fipfit = new TF1("fipfit","[0]*([1]+[2]*log(x)+[3]*log(x)*log(x))*tanh([4]*x-[5])",0.5,8.);
+   TF1 *fittofpid = new TF1("fittofpid","[0]*([1]+[2]*log(x)+[3]*log(x)*log(x))*tanh([4]*x-[5])",0.9,8.);
+   TF1 *fipfit = new TF1("fipfit","[0]*([1]+[2]*log(x)+[3]*log(x)*log(x))*tanh([4]*x-[5])",0.9,8.);
    TF1 *fipfitnonhfe = new TF1("fipfitnonhfe","[0]*([1]+[2]*log(x)+[3]*log(x)*log(x))*tanh([4]*x-[5])",0.3,10.0);
 
    TCanvas * cefficiencyParamtof = new TCanvas("efficiencyParamtof","efficiencyParamtof",600,600);
@@ -2890,11 +2902,15 @@ void AliHFEspectrum::SetParameterizedEff(AliCFContainer *container, AliCFContain
    efficiencyesdTOFPIDD[0]->Draw("same");
 
    //signal mc fit
-   fEfficiencyTOFPIDD[0]->SetLineColor(2);
-   fEfficiencyTOFPIDD[0]->Draw("same");
+   if(fEfficiencyTOFPIDD[0]){
+     fEfficiencyTOFPIDD[0]->SetLineColor(2);
+     fEfficiencyTOFPIDD[0]->Draw("same");
+   }
    //mb esd fit
-   fEfficiencyesdTOFPIDD[0]->SetLineColor(3);
-   fEfficiencyesdTOFPIDD[0]->Draw("same");
+   if(fEfficiencyesdTOFPIDD[0]){
+       fEfficiencyesdTOFPIDD[0]->SetLineColor(3);
+       fEfficiencyesdTOFPIDD[0]->Draw("same");
+     }
 
    TLegend *legtofeff = new TLegend(0.3,0.15,0.79,0.44);
    legtofeff->AddEntry(efficiencysigTOFPIDD[0],"TOF PID Step Efficiency","");
@@ -3027,7 +3043,7 @@ void AliHFEspectrum::SetParameterizedEff(AliCFContainer *container, AliCFContain
      fEfficiencyCharmSigD[icentr]->Fit(fipfit,"R");
      fEfficiencyCharmSigD[icentr]->GetYaxis()->SetTitle("Efficiency");
      fEfficiencyIPCharmD[icentr] = fEfficiencyCharmSigD[icentr]->GetFunction("fipfit");
-
+     
      if(fIPParameterizedEff){
        fipfitnonhfe->SetParameters(0.5,0.319,0.0157,0.00664,6.77,2.08);
        fipfitnonhfe->SetLineColor(3);
@@ -3090,10 +3106,12 @@ void AliHFEspectrum::SetParameterizedEff(AliCFContainer *container, AliCFContain
      fConversionEff[0]->Draw("same");
      fNonHFEEff[0]->Draw("same");
    }
-
-   fEfficiencyIPBeautyD[0]->Draw("same");
-   fEfficiencyIPBeautyesdD[0]->Draw("same");
-   fEfficiencyIPCharmD[0]->Draw("same");
+   if(fEfficiencyIPBeautyD[0])
+      fEfficiencyIPBeautyD[0]->Draw("same");
+   if(fEfficiencyIPBeautyesdD[0])
+     fEfficiencyIPBeautyesdD[0]->Draw("same");
+   if( fEfficiencyIPCharmD[0])
+     fEfficiencyIPCharmD[0]->Draw("same");
    if(fIPParameterizedEff){
      fEfficiencyIPConversionD[0]->Draw("same");
      fEfficiencyIPNonhfeD[0]->Draw("same");
@@ -3547,12 +3565,13 @@ void AliHFEspectrum::CalculateNonHFEsyst(Int_t centrality){
   AliCFDataGrid *convSourceGrid[kElecBgSources][kBgLevels];
   AliCFDataGrid *nonHFESourceGrid[kElecBgSources][kBgLevels];
 
-  AliCFDataGrid *bgLevelGrid[kBgLevels];
+  AliCFDataGrid *bgLevelGrid[2][kBgLevels];//for pi0 and eta based errors
   AliCFDataGrid *bgNonHFEGrid[kBgLevels];
   AliCFDataGrid *bgConvGrid[kBgLevels];
 
   Int_t stepbackground = 3;
   Int_t* bins=new Int_t[1];
+  const Char_t *bgBase[2] = {"pi0","eta"};
  
   bins[0]=fConversionEff[centrality]->GetNbinsX();
    
@@ -3571,98 +3590,132 @@ void AliHFEspectrum::CalculateNonHFEsyst(Int_t centrality){
     }
     
     bgConvGrid[iLevel] = (AliCFDataGrid*)convSourceGrid[0][iLevel]->Clone();
-    for(Int_t iSource = 1; iSource < kElecBgSources; iSource++){
+    for(Int_t iSource = 2; iSource < kElecBgSources; iSource++){
       bgConvGrid[iLevel]->Add(convSourceGrid[iSource][iLevel]);
     }
+    if(!fEtaSyst)
+      bgConvGrid[iLevel]->Add(convSourceGrid[1][iLevel]);
     
     bgNonHFEGrid[iLevel] = (AliCFDataGrid*)nonHFESourceGrid[0][iLevel]->Clone(); 
-    for(Int_t iSource = 1; iSource < kElecBgSources; iSource++){//add other sources to get overall background from all meson decays
+    for(Int_t iSource = 2; iSource < kElecBgSources; iSource++){//add other sources to pi0, to get overall background from all meson decays, exception: eta (independent error calculation)
       bgNonHFEGrid[iLevel]->Add(nonHFESourceGrid[iSource][iLevel]);
     }
+    if(!fEtaSyst)
+      bgNonHFEGrid[iLevel]->Add(nonHFESourceGrid[1][iLevel]);
     
-    bgLevelGrid[iLevel] = (AliCFDataGrid*)bgConvGrid[iLevel]->Clone();
-    bgLevelGrid[iLevel]->Add(bgNonHFEGrid[iLevel]);
+    bgLevelGrid[0][iLevel] = (AliCFDataGrid*)bgConvGrid[iLevel]->Clone();
+    bgLevelGrid[0][iLevel]->Add(bgNonHFEGrid[iLevel]);
+    if(fEtaSyst){
+      bgLevelGrid[1][iLevel] = (AliCFDataGrid*)nonHFESourceGrid[1][iLevel]->Clone();//background for eta source
+      bgLevelGrid[1][iLevel]->Add(convSourceGrid[1][iLevel]);
+    }
   }
   
-  
-  //Now subtract the mean from upper, and lower from mean container to get the error based on the pion yield uncertainty (-> this error sums linearly, since its contribution to all meson yields is correlated)
-  AliCFDataGrid *bgErrorGrid[2];
-  bgErrorGrid[0] = (AliCFDataGrid*)bgLevelGrid[1]->Clone();
-  bgErrorGrid[1] = (AliCFDataGrid*)bgLevelGrid[2]->Clone();
-  bgErrorGrid[0]->Add(bgLevelGrid[0],-1.);
-  bgErrorGrid[1]->Add(bgLevelGrid[0],-1.);
+  //Now subtract the mean from upper, and lower from mean container to get the error based on the pion yield uncertainty (-> this error sums linearly, since its contribution to all meson yields is correlated; exception: eta errors in pp 7 TeV sum with others the gaussian way, as they are independent from pi0) 
+  AliCFDataGrid *bgErrorGrid[2][2];//for pions/eta error base, for lower/upper
+  TH1D* hBaseErrors[2][2];//pi0/eta and lower/upper
+  for(Int_t iErr = 0; iErr < 2; iErr++){//errors for pi0 and eta base
+    bgErrorGrid[iErr][0] = (AliCFDataGrid*)bgLevelGrid[iErr][1]->Clone();
+    bgErrorGrid[iErr][0]->Add(bgLevelGrid[iErr][0],-1.);
+    bgErrorGrid[iErr][1] = (AliCFDataGrid*)bgLevelGrid[iErr][2]->Clone();    
+    bgErrorGrid[iErr][1]->Add(bgLevelGrid[iErr][0],-1.);
+
+  //plot absolute differences between limit yields (upper/lower limit, based on pi0 and eta errors) and best estimate
  
-  //plot absolute differences between limit yields (upper/lower limit, based on pi0 errors) and best estimate
-  TH1D* hpiErrors[2];
-  hpiErrors[0] = (TH1D*)bgErrorGrid[0]->Project(0);
-  hpiErrors[0]->Scale(-1.);
-  hpiErrors[0]->SetTitle("Absolute systematic errors from non-HF meson decays and conversions");
-  hpiErrors[1] = (TH1D*)bgErrorGrid[1]->Project(0);
-
+    hBaseErrors[iErr][0] = (TH1D*)bgErrorGrid[iErr][0]->Project(0);
+    hBaseErrors[iErr][0]->Scale(-1.);
+    hBaseErrors[iErr][0]->SetTitle(Form("Absolute %s-based systematic errors from non-HF meson decays and conversions",bgBase[iErr]));
+    hBaseErrors[iErr][1] = (TH1D*)bgErrorGrid[iErr][1]->Project(0);
+    if(!fEtaSyst)break;
+  }
   
-
-   //Calculate the scaling errors for electrons from all mesons except for pions: square sum of (0.3 * best yield estimate), where 0.3 is the error generally assumed for m_t scaling
+  //Calculate the scaling errors for electrons from all mesons except for pions (and in pp 7 TeV case eta): square sum of (0.3 * best yield estimate), where 0.3 is the error generally assumed for m_t scaling
   TH1D *hSpeciesErrors[kElecBgSources-1];
   for(Int_t iSource = 1; iSource < kElecBgSources; iSource++){
+    if(fEtaSyst && (iSource == 1))continue;
     hSpeciesErrors[iSource-1] = (TH1D*)convSourceGrid[iSource][0]->Project(0);
     TH1D *hNonHFEtemp = (TH1D*)nonHFESourceGrid[iSource][0]->Project(0);
     hSpeciesErrors[iSource-1]->Add(hNonHFEtemp);
     hSpeciesErrors[iSource-1]->Scale(0.3);   
   }
-
-  TH1D *hOverallSystErrLow = (TH1D*)hSpeciesErrors[0]->Clone();
-  TH1D *hOverallSystErrUp = (TH1D*)hSpeciesErrors[0]->Clone();
-  TH1D *hScalingErrors = (TH1D*)hSpeciesErrors[0]->Clone();
+  
+  //Int_t firstBgSource = 0;//if eta systematics are not from scaling
+  //if(fEtaSyst){firstBgSource = 1;}//source 0 histograms are not filled if eta errors are independently determined!
+  TH1D *hOverallSystErrLow = (TH1D*)hSpeciesErrors[1]->Clone();
+  TH1D *hOverallSystErrUp = (TH1D*)hSpeciesErrors[1]->Clone();
+  TH1D *hScalingErrors = (TH1D*)hSpeciesErrors[1]->Clone();
 
   TH1D *hOverallBinScaledErrsUp = (TH1D*)hOverallSystErrUp->Clone();
   TH1D *hOverallBinScaledErrsLow = (TH1D*)hOverallSystErrLow->Clone();
 
   for(Int_t iBin = 1; iBin <= kBgPtBins; iBin++){
-    Double_t pi0basedErrLow = hpiErrors[0]->GetBinContent(iBin); 
-    Double_t pi0basedErrUp = hpiErrors[1]->GetBinContent(iBin);
-    
+    Double_t pi0basedErrLow,pi0basedErrUp,etaErrLow,etaErrUp;    
+    pi0basedErrLow = hBaseErrors[0][0]->GetBinContent(iBin); 
+    pi0basedErrUp = hBaseErrors[0][1]->GetBinContent(iBin);
+    if(fEtaSyst){
+      etaErrLow = hBaseErrors[1][0]->GetBinContent(iBin); 
+      etaErrUp = hBaseErrors[1][1]->GetBinContent(iBin);
+    }
+    else{ etaErrLow = etaErrUp = 0.;}
+
     Double_t sqrsumErrs= 0;
     for(Int_t iSource = 1; iSource < kElecBgSources; iSource++){
+      if(fEtaSyst && (iSource == 1))continue;
       Double_t scalingErr=hSpeciesErrors[iSource-1]->GetBinContent(iBin);
       sqrsumErrs+=(scalingErr*scalingErr);
     }
     for(Int_t iErr = 0; iErr < 2; iErr++){
-      hpiErrors[iErr]->SetBinContent(iBin,hpiErrors[iErr]->GetBinContent(iBin)/hpiErrors[iErr]->GetBinWidth(iBin));
+      for(Int_t iLevel = 0; iLevel < 2; iLevel++){
+        hBaseErrors[iErr][iLevel]->SetBinContent(iBin,hBaseErrors[iErr][iLevel]->GetBinContent(iBin)/hBaseErrors[iErr][iLevel]->GetBinWidth(iBin));
+      }
+      if(!fEtaSyst)break;
     }
-    hOverallSystErrUp->SetBinContent(iBin, TMath::Sqrt((pi0basedErrUp*pi0basedErrUp)+sqrsumErrs));
-    hOverallSystErrLow->SetBinContent(iBin, TMath::Sqrt((pi0basedErrLow*pi0basedErrLow)+sqrsumErrs));
+    hOverallSystErrUp->SetBinContent(iBin, TMath::Sqrt((pi0basedErrUp*pi0basedErrUp)+(etaErrUp*etaErrUp)+sqrsumErrs));
+    hOverallSystErrLow->SetBinContent(iBin, TMath::Sqrt((pi0basedErrLow*pi0basedErrLow)+(etaErrLow*etaErrLow)+sqrsumErrs));
     hScalingErrors->SetBinContent(iBin, TMath::Sqrt(sqrsumErrs)/hScalingErrors->GetBinWidth(iBin));
 
     hOverallBinScaledErrsUp->SetBinContent(iBin,hOverallSystErrUp->GetBinContent(iBin)/hOverallBinScaledErrsUp->GetBinWidth(iBin));
     hOverallBinScaledErrsLow->SetBinContent(iBin,hOverallSystErrLow->GetBinContent(iBin)/hOverallBinScaledErrsLow->GetBinWidth(iBin));           
   }
    
-
-   // /hOverallSystErrUp->GetBinWidth(iBin))
   
   TCanvas *cPiErrors = new TCanvas("cPiErrors","cPiErrors",1000,600);
   cPiErrors->cd();
   cPiErrors->SetLogx();
   cPiErrors->SetLogy();
-  hpiErrors[0]->Draw();
-  hpiErrors[1]->SetMarkerColor(kBlack);
-  hpiErrors[1]->SetLineColor(kBlack);
-  hpiErrors[1]->Draw("SAME");
-  hOverallBinScaledErrsUp->SetMarkerColor(kBlue);
-  hOverallBinScaledErrsUp->SetLineColor(kBlue);
-  hOverallBinScaledErrsUp->Draw("SAME");
+  hBaseErrors[0][0]->Draw();
+  //hBaseErrors[0][1]->SetMarkerColor(kBlack);
+  //hBaseErrors[0][1]->SetLineColor(kBlack);
+  //hBaseErrors[0][1]->Draw("SAME");
+  if(fEtaSyst){
+    hBaseErrors[1][0]->Draw("SAME");
+    hBaseErrors[1][0]->SetMarkerColor(kBlack);
+    hBaseErrors[1][0]->SetLineColor(kBlack);
+  //hBaseErrors[1][1]->SetMarkerColor(13);
+  //hBaseErrors[1][1]->SetLineColor(13);
+  //hBaseErrors[1][1]->Draw("SAME");
+  }
+  //hOverallBinScaledErrsUp->SetMarkerColor(kBlue);
+  //hOverallBinScaledErrsUp->SetLineColor(kBlue);
+  //hOverallBinScaledErrsUp->Draw("SAME");
   hOverallBinScaledErrsLow->SetMarkerColor(kGreen);
   hOverallBinScaledErrsLow->SetLineColor(kGreen);
   hOverallBinScaledErrsLow->Draw("SAME");
-  hScalingErrors->SetLineColor(11);
+  hScalingErrors->SetLineColor(kBlue);
   hScalingErrors->Draw("SAME");
 
   TLegend *lPiErr = new TLegend(0.6,0.6, 0.95,0.95);
-  lPiErr->AddEntry(hpiErrors[0],"Lower error from pion error");
-  lPiErr->AddEntry(hpiErrors[1],"Upper error from pion error");
+  lPiErr->AddEntry(hBaseErrors[0][0],"Lower error from pion error");
+  //lPiErr->AddEntry(hBaseErrors[0][1],"Upper error from pion error");
+  if(fEtaSyst){
+  lPiErr->AddEntry(hBaseErrors[1][0],"Lower error from eta error");
+  //lPiErr->AddEntry(hBaseErrors[1][1],"Upper error from eta error");
+  }
   lPiErr->AddEntry(hScalingErrors, "scaling error");
   lPiErr->AddEntry(hOverallBinScaledErrsLow, "overall lower systematics");
-  lPiErr->AddEntry(hOverallBinScaledErrsUp, "overall upper systematics");
+  //lPiErr->AddEntry(hOverallBinScaledErrsUp, "overall upper systematics");
   lPiErr->Draw("SAME");
 
   //Normalize errors
@@ -3697,7 +3750,10 @@ void AliHFEspectrum::CalculateNonHFEsyst(Int_t centrality){
 
 
   AliCFDataGrid *bgYieldGrid;
-  bgYieldGrid = (AliCFDataGrid*)bgLevelGrid[0]->Clone();
+  if(fEtaSyst){
+    bgLevelGrid[0][0]->Add(bgLevelGrid[1][0]);//Addition of the eta background best estimate to the rest. Needed to be separated for error treatment - now overall background necessary! If no separate eta systematics exist, the corresponding grid has already been added before.
+  }
+  bgYieldGrid = (AliCFDataGrid*)bgLevelGrid[0][0]->Clone();
 
   TH1D *hBgYield = (TH1D*)bgYieldGrid->Project(0);
   TH1D* hRelErrUp = (TH1D*)hOverallSystErrUp->Clone();
@@ -3745,3 +3801,94 @@ void AliHFEspectrum::CalculateNonHFEsyst(Int_t centrality){
   
 }
 
+//____________________________________________________________
+void AliHFEspectrum::UnfoldBG(AliCFDataGrid* const bgsubpectrum){
+
+  //
+  // Unfold backgrounds to check its sanity
+  //
+
+  AliCFContainer *mcContainer = GetContainer(kMCContainerCharmMC);
+  //AliCFContainer *mcContainer = GetContainer(kMCContainerMC);
+  if(!mcContainer){
+    AliError("MC Container not available");
+  }
+
+  if(!fCorrelation){
+    AliError("No Correlation map available");
+  }
+
+  // Data 
+  AliCFDataGrid *dataGrid = 0x0;
+  dataGrid = bgsubpectrum;
+
+  // Guessed
+  AliCFDataGrid* guessedGrid = new AliCFDataGrid("guessed","",*mcContainer, fStepGuessedUnfolding);
+  THnSparse* guessedTHnSparse = ((AliCFGridSparse*)guessedGrid->GetData())->GetGrid();
+
+  // Efficiency
+  AliCFEffGrid* efficiencyD = new AliCFEffGrid("efficiency","",*mcContainer);
+  efficiencyD->CalculateEfficiency(fStepMC+2,fStepTrue);
+
+  // Unfold background spectra
+  Int_t nDim=1;
+  if(fBeamType==0)nDim = 1;
+  if(fBeamType==1)nDim = 2;
+  AliCFUnfolding unfolding("unfolding","",nDim,fCorrelation,efficiencyD->GetGrid(),dataGrid->GetGrid(),guessedTHnSparse);
+  if(fUnSetCorrelatedErrors) unfolding.UnsetCorrelatedErrors();
+  unfolding.SetMaxNumberOfIterations(fNumberOfIterations);
+  if(fSetSmoothing) unfolding.UseSmoothing();
+  unfolding.Unfold();
+
+  // Results
+  THnSparse* result = unfolding.GetUnfolded();
+  TCanvas *ctest = new TCanvas("yvonnetest","yvonnetest",1000,600);
+  if(fBeamType==1)
+  {
+      ctest->Divide(2,2);
+      ctest->cd(1);
+      result->GetAxis(0)->SetRange(1,1);
+      TH1D* htest1=(TH1D*)result->Projection(0);
+      htest1->Draw();
+      ctest->cd(2);
+      result->GetAxis(0)->SetRange(1,1);
+      TH1D* htest2=(TH1D*)result->Projection(1);
+      htest2->Draw();
+      ctest->cd(3);
+      result->GetAxis(0)->SetRange(6,6);
+      TH1D* htest3=(TH1D*)result->Projection(0);
+      htest3->Draw();
+      ctest->cd(4);
+      result->GetAxis(0)->SetRange(6,6);
+      TH1D* htest4=(TH1D*)result->Projection(1);
+      htest4->Draw();
+
+  }
+
+
+
+
+
+  TGraphErrors* unfoldedbgspectrumD = Normalize(result);
+  if(!unfoldedbgspectrumD) {
+    AliError("Unfolded background spectrum doesn't exist");
+  }
+  else{
+    TFile *file = TFile::Open("unfoldedbgspectrum.root","recreate");
+    if(fBeamType==0)unfoldedbgspectrumD->Write("unfoldedbgspectrum");
+
+    if(fBeamType==1)
+    {
+        Int_t centr=1;
+       result->GetAxis(0)->SetRange(centr,centr);
+       unfoldedbgspectrumD = Normalize(result,centr-1);
+       unfoldedbgspectrumD->Write("unfoldedbgspectrum_centr0_20");
+        centr=6;
+       result->GetAxis(0)->SetRange(centr,centr);
+       unfoldedbgspectrumD = Normalize(result,centr-1);
+        unfoldedbgspectrumD->Write("unfoldedbgspectrum_centr40_80");
+    }
+
+    file->Close();
+  }
+}
index 90fe822..dea8b5c 100644 (file)
@@ -76,6 +76,7 @@ class AliHFEspectrum : public TNamed{
     AliCFDataGrid *CorrectParametrizedEfficiency(AliCFDataGrid* const bgsubpectrum = 0x0);
    
     TList *Unfold(AliCFDataGrid* const bgsubpectrum = 0x0);
+    void UnfoldBG(AliCFDataGrid* const bgsubpectrum);
     AliCFDataGrid *CorrectForEfficiency(AliCFDataGrid* const bgsubpectrum = 0x0);
    
     TGraphErrors *Normalize(THnSparse * const spectrum,Int_t i = 0) const;
@@ -88,6 +89,7 @@ class AliHFEspectrum : public TNamed{
     void SetContainer(AliCFContainer *cont, AliHFEspectrum::CFContainer_t type);
     void SetEfficiencyFunction(TF1 *efficiencyFunction) { fEfficiencyFunction = efficiencyFunction; };
     void SetPbPbAnalysis(Bool_t isPbPb = kFALSE) { fBeamType=(Char_t) isPbPb; };
+    void SetEtaSyst(Bool_t etaSyst = kTRUE) { fEtaSyst = etaSyst; };
 
     void SetParameterizedEff(AliCFContainer *container, AliCFContainer *containermb, AliCFContainer *containeresd, AliCFContainer *containeresdmb, Int_t *dimensions);
     
@@ -105,6 +107,7 @@ class AliHFEspectrum : public TNamed{
     void SetUnSetCorrelatedErrors(Bool_t unsetcorrelatederrors) {fUnSetCorrelatedErrors = unsetcorrelatederrors;};
     void SetSmoothing(Bool_t setSmoothing) {fSetSmoothing = setSmoothing;};
     void SetTestOneBinCentrality(Double_t centralitymin, Double_t centralitymax) { fTestCentralityLow = centralitymin; fTestCentralityHigh = centralitymax;}
+    void SetFillMoreCorrelationMatrix(Bool_t fillMoreCorrelationMatrix) { fFillMoreCorrelationMatrix = fillMoreCorrelationMatrix;}
 
     void SetNCentralityBinAtTheEnd(Int_t nCentralityBinAtTheEnd) {fNCentralityBinAtTheEnd = nCentralityBinAtTheEnd; };
     void SetLowHighBoundaryCentralityBinAtTheEnd(Int_t low, Int_t high, Int_t i) { fLowBoundaryCentralityBinAtTheEnd[i] = low; fHighBoundaryCentralityBinAtTheEnd[i] = high;};
@@ -123,6 +126,7 @@ class AliHFEspectrum : public TNamed{
     void SetDumpToFile(Bool_t dumpToFile) { fDumpToFile=dumpToFile; }; 
   
     void SetDebugLevel(Int_t debugLevel, Bool_t writeToFile = kFALSE) { fDebugLevel = debugLevel; fWriteToFile = writeToFile; };
+    void SetUnfoldBG() { fUnfoldBG = kTRUE; };
 
 
     AliCFDataGrid* GetRawBspectra2ndMethod();
@@ -213,6 +217,7 @@ class AliHFEspectrum : public TNamed{
     Int_t fHighBoundaryCentralityBinAtTheEnd[20];  // Boundary of the bins
     Int_t fTestCentralityLow;                      // To test one bin in centrality only
     Int_t fTestCentralityHigh;                     // To test one bin in centrality only
+    Bool_t fFillMoreCorrelationMatrix;             // For low stats to have reasonable errors
 
     THnSparseF *fHadronEffbyIPcut;// container for hadron efficiency by IP cut
     TH1D *fEfficiencyCharmSigD[kCentrality]; // charm IP cut eff from signal enhanced MC
@@ -227,10 +232,12 @@ class AliHFEspectrum : public TNamed{
     TH1D *fBSpectrum2ndMethod;             // beauty spectrum for 2nd method
     const char *fkBeauty2ndMethodfilename;      // name of file, which contains beauty spectrum for 2ndmethod
     Char_t fBeamType;             // beamtype; default -1; pp =0; PbPb=1
+    Bool_t fEtaSyst;              // pp 2.76 TeV (= kTRUE) or 7 TeV (= kFALSE)
 
 
     Int_t fDebugLevel;            // Debug Level
     Bool_t fWriteToFile;           // Write plots to eps files
+    Bool_t fUnfoldBG;             // flag to unfold backgroud
 
     ClassDef(AliHFEspectrum, 1) 
 };
index 074eeeb..7347dbf 100644 (file)
@@ -43,6 +43,7 @@
 #include "AliHFEpidBase.h"
 #include "AliHFEpidQAmanager.h"
 #include "AliHFEpidTPC.h"
+#include "AliHFEpidTRD.h"
 #include "AliHFEpidTOF.h"
 #include "AliHFEtools.h"
 #include "AliHFEtofPIDqa.h"
@@ -153,7 +154,7 @@ void AliHFEtofPIDqa::Initialize(){
   const Double_t kMaxP = 20.;
   // Quantities where one can switch between low and high resolution
   Int_t kPbins = fQAmanager->HasHighResolutionHistos() ?  1000 : 100;
-  Int_t kSigmaBins = fQAmanager->HasHighResolutionHistos() ? 1400 : 240;
+  Int_t kSigmaBins = fQAmanager->HasHighResolutionHistos() ? 1400 : 140;
 
   // 1st histogram: TOF sigmas: (species, p nsigma, step)
   Int_t nBinsSigma[5] = {kPIDbins, kPbins, kSigmaBins, kSteps, kCentralityBins};
@@ -171,12 +172,15 @@ void AliHFEtofPIDqa::ProcessTrack(const AliHFEpidObject *track, AliHFEdetPIDqa::
   // Fill TPC histograms
   //
   //AliHFEpidObject::AnalysisType_t anatype = track->IsESDanalysis() ? AliHFEpidObject::kESDanalysis : AliHFEpidObject::kAODanalysis;
+  AliHFEpidObject::AnalysisType_t anatype = track->IsESDanalysis() ? AliHFEpidObject::kESDanalysis : AliHFEpidObject::kAODanalysis;
+
   Float_t centrality = track->GetCentrality();
   Int_t species = track->GetAbInitioPID();
   if(species >= AliPID::kSPECIES) species = -1;
 
   AliDebug(1, Form("Monitoring particle of type %d for step %d", species, step));
   AliHFEpidTOF *tofpid= dynamic_cast<AliHFEpidTOF *>(fQAmanager->GetDetectorPID(AliHFEpid::kTOFpid));
+  AliHFEpidTRD *trdpid= dynamic_cast<AliHFEpidTRD *>(fQAmanager->GetDetectorPID(AliHFEpid::kTRDpid));
   
   const AliPIDResponse *pidResponse = tofpid ? tofpid->GetPIDResponse() : NULL;
   Double_t contentSignal[5];
@@ -186,10 +190,63 @@ void AliHFEtofPIDqa::ProcessTrack(const AliHFEpidObject *track, AliHFEdetPIDqa::
   contentSignal[3] = step;
   contentSignal[4] = centrality;
   fHistos->Fill("tofnSigma", contentSignal);
-  if(species > -1){
-    contentSignal[2] = pidResponse ? pidResponse->NumberOfSigmasTPC(track->GetRecTrack(), AliPID::kElectron) : 0.;
+  //if(species > -1){
+  contentSignal[1] =trdpid ? trdpid->GetP(track->GetRecTrack(), anatype) : 0.;
+  contentSignal[2] = pidResponse ? pidResponse->NumberOfSigmasTPC(track->GetRecTrack(), AliPID::kElectron) : 0.;
     fHistos->Fill("tofMonitorTPC", contentSignal);
+  //}
+}
+
+//_________________________________________________________
+TH2 *AliHFEtofPIDqa::MakeTPCspectrumNsigma(AliHFEdetPIDqa::EStep_t step, Int_t species, Int_t centralityClass){
+  //
+  // Get the TPC control histogram for the TRD selection step (either before or after PID)
+  //
+  THnSparseF *histo = dynamic_cast<THnSparseF *>(fHistos->Get("tofMonitorTPC"));
+  if(!histo){
+    AliError("QA histogram monitoring TPC nSigma not available");
+    return NULL;
+  }
+  if(species > -1 && species < AliPID::kSPECIES){
+    // cut on species (if available)
+    histo->GetAxis(0)->SetRange(species + 2, species + 2); // undef + underflow
+  }
+  TString centname, centtitle;
+  Bool_t hasCentralityInfo = kTRUE;
+  if(centralityClass > -1){
+    if(histo->GetNdimensions() < 5){
+      AliError("Centrality Information not available");
+      centname = centtitle = "MinBias";
+      hasCentralityInfo = kFALSE;
+    } else {
+      // Project centrality classes
+      // -1 is Min. Bias
+      histo->GetAxis(4)->SetRange(centralityClass+1, centralityClass+1);
+      centname = Form("Cent%d", centralityClass);
+      centtitle = Form("Centrality %d", centralityClass);
+    }
+  } else {
+    histo->GetAxis(4)->SetRange(1, histo->GetAxis(4)->GetNbins()-1);
+    centname = centtitle = "MinBias";
+    hasCentralityInfo = kTRUE;
   }
+  histo->GetAxis(3)->SetRange(step + 1, step + 1); 
+
+  TH2 *hSpec = histo->Projection(2, 1);
+  // construct title and name
+  TString stepname = step == AliHFEdetPIDqa::kBeforePID ? "before" : "after";
+  TString speciesname = species > -1 && species < AliPID::kSPECIES ? AliPID::ParticleName(species) : "all Particles";
+  TString specID = species > -1 && species < AliPID::kSPECIES ? AliPID::ParticleName(species) : "unid";
+  TString histname = Form("hSigmaTPC%s%s%s", specID.Data(), stepname.Data(), centname.Data());
+  TString histtitle = Form("TPC Sigma for %s %s PID %s", speciesname.Data(), stepname.Data(), centtitle.Data());
+  hSpec->SetName(histname.Data());
+  hSpec->SetTitle(histtitle.Data());
+
+  // Unset range on the original histogram
+  histo->GetAxis(0)->SetRange(0, histo->GetAxis(0)->GetNbins());
+  histo->GetAxis(3)->SetRange(0, histo->GetAxis(3)->GetNbins());
+  if(hasCentralityInfo)histo->GetAxis(4)->SetRange(0, histo->GetAxis(4)->GetNbins());
+  return hSpec; 
 }
 
 //_________________________________________________________
index ff2b7db..42553e2 100644 (file)
@@ -44,6 +44,7 @@ class AliHFEtofPIDqa : public AliHFEdetPIDqa{
     virtual void Initialize();
     virtual void ProcessTrack(const AliHFEpidObject *track, AliHFEdetPIDqa::EStep_t step);
 
+    TH2 *MakeTPCspectrumNsigma(AliHFEdetPIDqa::EStep_t step, Int_t species = -1, Int_t centralityClass = -1);
     TH2 *MakeSpectrumNSigma(AliHFEdetPIDqa::EStep_t step, Int_t species = -1);
     TH1 *GetHistogram(const char *name);
     AliHFEcollection *GetHistoCollection() const { return fHistos; }
index dab9e9c..0bb7b5d 100644 (file)
@@ -23,6 +23,7 @@
 #include <TArrayD.h>
 #include <TMath.h>
 #include <TParticle.h>
+#include <TF1.h>
 #include "TH1.h"
 #include "TH1D.h"
 #include "TH2.h"
@@ -425,3 +426,32 @@ TH1D* AliHFEtools::GraphToHist(TGraph* g, Double_t firstBinWidth, Bool_t exchang
 
     return result;
 }
+
+//__________________________________________
+void AliHFEtools::BinParameterisation(const TF1 &fun, const TArrayD &xbins, TArrayD &bincontent){
+    //
+    // Calculate binned version of a function defined as the integral of x*f(x) in
+    // the integration range xmin,xmax, where xmin and xmax are the bin limits, divided
+    // by the binwidth. The function is important in case of steeply falling functions
+    //
+    // Parameters
+    //   fun:           the function to be binned
+    //   xbins:         the bin limits
+    //   bincontent:    the binned parameterisation
+    //
+    TString expression(Form("x*%s", fun.GetName()));
+    Double_t xmin(0), xmax(0);
+    fun.GetRange(xmin,xmax);
+    // check range
+    xmin = TMath::Min(xmin, xbins[0]);
+    xmax = TMath::Max(xmax, xbins[xbins.GetSize()-1]);
+    TF1 helper("helper",expression.Data(),xmin,xmax);   // make function x*f(x)
+    if(bincontent.GetSize() != xbins.GetSize()-1)
+        bincontent.Set(xbins.GetSize()-1); // Adapt array to number of bins
+    //Caclulate Binned
+    for(Int_t ib = 0; ib < xbins.GetSize()-1; ib++){
+        xmin = xbins[ib];
+        xmax = xbins[ib+1];
+        bincontent[ib] = (helper.Integral(xmin, xmax))/(xmax - xmin);
+    }
+}
index 4b1b45c..7780c2b 100644 (file)
@@ -30,6 +30,7 @@ class AliVParticle;
 class TGraph;
 class TGraphErrors;
 class TH1D;
+class TF1;
 class TString;
 
 class AliHFEtools : public TObject{
@@ -53,6 +54,7 @@ class AliHFEtools : public TObject{
     static TH1D* GraphToHist(TGraph* g = 0, Double_t firstBinWidth = -1, Bool_t exchange=kFALSE, Int_t markerstyle=8, Int_t markercolor=2, Float_t markersize=0.7);
     static Bool_t ExchangeXYGraph(TGraph* g = 0);
     static Bool_t ExchangeXYGraphErrors(TGraphErrors* g = 0);
+    static void BinParameterisation(const TF1 &fun, const TArrayD &xbins, TArrayD &bincontent);
 
   private:
       AliHFEtools(const AliHFEtools &);