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
hfe/AliHFEdebugTreeTask.cxx
hfe/AliHFEVZEROEventPlane.cxx
hfe/AliAnalysisTaskHFEFlow.cxx
- hfe/AliAnalysisTaskHFEFlowData.cxx
hfe/AliSelectNonHFE.cxx
)
#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+;
#pragma link C++ class AliHFEVZEROEventPlane+;
#pragma link C++ class AliAnalysisTaskHFEFlow+;
-#pragma link C++ class AliAnalysisTaskHFEFlowData+;
#pragma link C++ class AliSelectNonHFE+;
+++ /dev/null
-/**************************************************************************
-* 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;
-}
-
+++ /dev/null
-/**************************************************************************
-* 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
-
+++ /dev/null
-/**************************************************************************
-* 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;
-}
+++ /dev/null
-/**************************************************************************
-* 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
-
+++ /dev/null
-/**************************************************************************\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
+++ /dev/null
-/**************************************************************************\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
fMinClustersTPCPID(0),
fMinClustersITS(0),
fMinTrackletsTRD(0),
+ fMaxChi2TRD(-1.),
fCutITSPixel(0),
fCheckITSLayerStatus(kTRUE),
fCutITSDrift(0),
fTOFPIDStep(kFALSE),
fTOFMISMATCHStep(kFALSE),
fTPCPIDCLEANUPStep(kFALSE),
+ fITSpatternCut(kFALSE),
fUseMixedVertex(kTRUE),
fIsIPSigmacut(kFALSE),
fIsIPAbs(kTRUE),
fMinClustersTPCPID(0),
fMinClustersITS(0),
fMinTrackletsTRD(0),
+ fMaxChi2TRD(-1.),
fCutITSPixel(0),
fCheckITSLayerStatus(kTRUE),
fCutITSDrift(0),
fTOFPIDStep(kFALSE),
fTOFMISMATCHStep(kFALSE),
fTPCPIDCLEANUPStep(kFALSE),
+ fITSpatternCut(kFALSE),
fUseMixedVertex(kTRUE),
fIsIPSigmacut(kFALSE),
fIsIPAbs(kTRUE),
fMinClustersTPCPID(0),
fMinClustersITS(0),
fMinTrackletsTRD(0),
+ fMaxChi2TRD(-1.),
fCutITSPixel(0),
fCheckITSLayerStatus(0),
fCutITSDrift(0),
fTOFPIDStep(kFALSE),
fTOFMISMATCHStep(kFALSE),
fTPCPIDCLEANUPStep(kFALSE),
+ fITSpatternCut(c.fITSpatternCut),
fUseMixedVertex(kTRUE),
fIsIPSigmacut(kFALSE),
fIsIPAbs(kTRUE),
target.fMinClustersTPCPID = fMinClustersTPCPID;
target.fMinClustersITS = fMinClustersITS;
target.fMinTrackletsTRD = fMinTrackletsTRD;
+ target.fMaxChi2TRD = fMaxChi2TRD;
target.fCutITSPixel = fCutITSPixel;
target.fCheckITSLayerStatus = fCheckITSLayerStatus;
target.fCutITSDrift = fCutITSDrift;
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]);
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);
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);
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; };
kITSPixel = 4,
kMaxImpactParam = 5,
kKineMCCuts = 6,
- kITSDrift = 7,
+ kITSDrift = 7
} Require_t;
void SetParticleGenCutList();
void SetAcceptanceCutList();
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
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
+++ /dev/null
-/*************************************************************************
-* 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);
-
-}
-
+++ /dev/null
-/**************************************************************************
-* 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
<< "pdg=" << pdg
<< "ProductionVertex=" << productionVertex
<< "motherPdg=" << motherPdg
- << "source=" << source
+ << "source=" << source
<< "\n";
}
}
Double_t nSigmaTPC = pid->NumberOfSigmasTPC(©Track, 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;
unique=mctrackt->GetUniqueID();
AliMCParticle *mctrackmother = NULL;
+ AliMCParticle *mctrackmother2 = NULL;
if(!(mArr<0)){
if(mesonID>=AliHFEmcQA::kGammaPi0) { // conversion electron, be careful with the enum odering
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
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++){
<< "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]
<< "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
}
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;
+}
+
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
+++ /dev/null
-/*************************************************************************
-* 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;
-}
+++ /dev/null
-/**************************************************************************
-* 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
ClassImp(AliHFEextraCuts)
-const Int_t AliHFEextraCuts::fgkNQAhistos = 8;
+const Int_t AliHFEextraCuts::fgkNQAhistos = 9;
//______________________________________________________
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),
fMinNClustersTPCPID(c.fMinNClustersTPCPID),
fClusterRatioTPC(c.fClusterRatioTPC),
fMinTrackletsTRD(c.fMinTrackletsTRD),
+ fMaxChi2TRD(c.fMaxChi2TRD),
fMinNbITScls(c.fMinNbITScls),
fTRDtrackletsExact(c.fTRDtrackletsExact),
fPixelITS(c.fPixelITS),
fMinNClustersTPC = c.fMinNClustersTPC;
fMinNClustersTPCPID = c.fMinNClustersTPCPID;
fMinTrackletsTRD = c.fMinTrackletsTRD;
+ fMaxChi2TRD = c.fMaxChi2TRD;
fMinNbITScls = c.fMinNbITScls;
fTRDtrackletsExact = c.fTRDtrackletsExact;
fPixelITS = c.fPixelITS;
// 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
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);
}
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)){
}
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:
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)){
// 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;
}
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));
}
// //______________________________________________________
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);
}
//______________________________________________________
-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
//
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;
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){
//
}
}
+
+//______________________________________________________
+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;
+}
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); }
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);};
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);
kRejectKinkMother = 19,
kDriftITS = 20,
kTOFsignalDxy = 21,
- kNcuts = 22
+ kMaxTRDChi2 = 22,
+ kITSpattern = 23,
+ kNcuts = 24
} Cut_t;
enum{
//
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
fTRDtrackletsExact = exact;
}
+//__________________________________________________________
+void AliHFEextraCuts::SetMaxChi2TRD(Float_t maxchi2){
+ SETBIT(fRequirements, kMaxTRDChi2);
+ fMaxChi2TRD = maxchi2;
+}
+
+
//__________________________________________________________
void AliHFEextraCuts::SetMinNClustersTPC(Int_t minClusters, ETPCclusterDef_t tpcdef){
SETBIT(fRequirements, kMinNClustersTPC);
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];
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];
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());
}
}
+ //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){
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 ) {
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;
}
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;
}
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);
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
};
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()
, 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
};
, 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
};
#include <TF1.h>
#include <TMath.h>
+#include "AliTPCdEdxInfo.h"
#include "AliAODPid.h"
#include "AliAODTrack.h"
#include "AliAODMCParticle.h"
, fLineCrossingsEnabled(0)
, fkEtaCorrection(NULL)
, fHasCutModel(kFALSE)
+ , fUseOnlyOROC(kFALSE)
, fNsigmaTPC(3)
, fRejectionEnabled(0)
{
, fLineCrossingsEnabled(0)
, fkEtaCorrection(NULL)
, fHasCutModel(kFALSE)
+ , fUseOnlyOROC(kFALSE)
, fNsigmaTPC(3)
, fRejectionEnabled(0)
{
, fLineCrossingsEnabled(0)
, fkEtaCorrection(NULL)
, fHasCutModel(ref.fHasCutModel)
+ , fUseOnlyOROC(ref.fUseOnlyOROC)
, fNsigmaTPC(2)
, fRejectionEnabled(0)
{
target.fkEtaCorrection =fkEtaCorrection;
target.fLineCrossingsEnabled = fLineCrossingsEnabled;
target.fHasCutModel = fHasCutModel;
+ target.fUseOnlyOROC = fUseOnlyOROC;
target.fNsigmaTPC = fNsigmaTPC;
target.fRejectionEnabled = fRejectionEnabled;
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()){
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){
//
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);
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;
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
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
// and the appropriate correlation matrix
//
-
+
if(fBeauty2ndMethod) CallInputFileForBeauty2ndMethod();
Int_t kNdim = 3;
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;
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");
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;
delete[] nBinPbPb;
delete[] binsPbPb;
+ if(fUnfoldBG) UnfoldBG(charmBackgroundGrid);
+
return charmBackgroundGrid;
}
// 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;
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);
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","");
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);
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");
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();
}
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
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();
}
+//____________________________________________________________
+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();
+ }
+}
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;
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);
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;};
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();
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
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)
};
#include "AliHFEpidBase.h"
#include "AliHFEpidQAmanager.h"
#include "AliHFEpidTPC.h"
+#include "AliHFEpidTRD.h"
#include "AliHFEpidTOF.h"
#include "AliHFEtools.h"
#include "AliHFEtofPIDqa.h"
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};
// 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];
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;
}
//_________________________________________________________
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; }
#include <TArrayD.h>
#include <TMath.h>
#include <TParticle.h>
+#include <TF1.h>
#include "TH1.h"
#include "TH1D.h"
#include "TH2.h"
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);
+ }
+}
class TGraph;
class TGraphErrors;
class TH1D;
+class TF1;
class TString;
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 &);
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff