-/**************************************************************************\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
-// The analysis task:\r
-// Filling an AliCFContainer with the quantities pt, eta and phi\r
-// for tracks which survivied the particle cuts (MC resp. ESD tracks)\r
-// Track selection is done using the AliHFE package\r
-// \r
-// Author:\r
-// Raphaelle Bailhache <R.Bailhache@gsi.de>\r
-// Markus Fasel <M.Fasel@gsi.de>\r
-// Matus Kalisky <matus.kalisky@cern.ch>\r
-// MinJung Kweon <minjung@physi.uni-heidelberg.de>\r
-//\r
-#include <TAxis.h>\r
-#include <TBits.h>\r
-#include <TCanvas.h>\r
-#include <TChain.h>\r
-#include <TDirectory.h>\r
-#include <TFile.h>\r
-#include <TH3D.h>\r
-#include <TIterator.h>\r
-#include <TList.h>\r
-#include <TLegend.h>\r
-#include <TMath.h>\r
-#include <TObjArray.h>\r
-#include <TObjString.h>\r
-#include <TParticle.h>\r
-#include <TProfile.h>\r
-#include <TString.h>\r
-#include <TF1.h>\r
-#include <TTree.h>\r
-\r
-#include "AliESDtrackCuts.h"\r
-#include "AliAnalysisManager.h"\r
-#include "AliAnalysisUtils.h"\r
-#include "AliAODInputHandler.h"\r
-#include "AliAODMCParticle.h"\r
-#include "AliAODTrack.h"\r
-#include "AliAODVertex.h"\r
-#include "AliCentrality.h"\r
-#include "AliCFContainer.h"\r
-#include "AliCFManager.h"\r
-#include "AliESDEvent.h"\r
-#include "AliESDInputHandler.h"\r
-#include "AliESDtrack.h"\r
-#include "AliLog.h"\r
-#include "AliMCEvent.h"\r
-#include "AliMCEventHandler.h"\r
-#include "AliMCParticle.h"\r
-#include "AliMultiplicity.h"\r
-#include "AliPID.h"\r
-#include "AliPIDResponse.h"\r
-#include "AliOADBContainer.h"\r
-#include "AliStack.h"\r
-#include "AliTriggerAnalysis.h"\r
-#include "AliVVertex.h"\r
-\r
-#include "AliHFEcollection.h"\r
-#include "AliHFEcontainer.h"\r
-#include "AliHFEcuts.h"\r
-#include "AliHFEelecbackground.h"\r
-#include "AliHFENonPhotonicElectron.h"\r
-#include "AliHFEmcQA.h"\r
-#include "AliHFEpairs.h"\r
-#include "AliHFEpid.h"\r
-#include "AliHFEpidQAmanager.h"\r
-#include "AliHFEsecVtxs.h"\r
-#include "AliHFEsecVtx.h"\r
-#include "AliHFEsignalCuts.h"\r
-#include "AliHFEtaggedTrackAnalysis.h"\r
-#include "AliHFEtools.h"\r
-#include "AliHFEvarManager.h"\r
-#include "AliAnalysisTaskHFE.h"\r
-#include "AliAODMCHeader.h"\r
-#include "TClonesArray.h"\r
-\r
-ClassImp(AliAnalysisTaskHFE)\r
-\r
-//____________________________________________________________\r
-AliAnalysisTaskHFE::AliAnalysisTaskHFE():\r
-AliAnalysisTaskSE("PID efficiency Analysis")\r
- , fAODMCHeader(NULL)\r
- , fAODArrayMCInfo(NULL)\r
- , fQAlevel(0)\r
- , fPlugins(0)\r
- , fCollisionSystem(3)\r
- , fFillSignalOnly(kTRUE)\r
- , fFillNoCuts(kFALSE)\r
- , fApplyCutAOD(kFALSE)\r
- , fBackGroundFactorApply(kFALSE)\r
- , fRemovePileUp(kFALSE)\r
- , fIdentifiedAsPileUp(kFALSE)\r
- , fIdentifiedAsOutInz(kFALSE)\r
- , fPassTheEventCut(kFALSE)\r
- , fRejectKinkMother(kTRUE)\r
- , fisppMultiBin(kFALSE)\r
- , fPbPbUserCentralityBinning(kFALSE)\r
- , fRemoveFirstEvent(kFALSE)\r
- , fisNonHFEsystematics(kFALSE)\r
- , fSpecialTrigger(NULL)\r
- , fCentralityF(-1)\r
- , fCentralityPercent(-1)\r
- , fCentralityEstimator("V0M")\r
- , fContributors(0.5)\r
- , fWeightBackGround(0.)\r
- , fVz(0.0)\r
- , fContainer(NULL)\r
- , fVarManager(NULL)\r
- , fSignalCuts(NULL)\r
- , fCFM(NULL)\r
- , fTriggerAnalysis(NULL)\r
- , fPID(NULL)\r
- , fPIDqa(NULL)\r
- , fPIDpreselect(NULL)\r
- , fCuts(NULL)\r
- , fTaggedTrackCuts(NULL)\r
- , fCleanTaggedTrack(kFALSE)\r
- , fVariablesTRDTaggedTrack(kFALSE)\r
- , fAnalysisUtils(NULL)\r
- , fCutspreselect(NULL)\r
- , fSecVtx(NULL)\r
- , fElecBackGround(NULL)\r
- , fMCQA(NULL)\r
- , fTaggedTrackAnalysis(NULL)\r
- , fExtraCuts(NULL)\r
- , fBackgroundSubtraction(NULL)\r
- , fTRDTrigger(kFALSE)\r
- , fWhichTRDTrigger(0)\r
- , fQA(NULL)\r
- , fOutput(NULL)\r
- , fHistMCQA(NULL)\r
- , fHistSECVTX(NULL)\r
- , fHistELECBACKGROUND(NULL)\r
- , fQACollection(NULL)\r
-{\r
- //\r
- // Dummy constructor\r
- //\r
- memset(fElecBackgroundFactor, 0, sizeof(Double_t) * kElecBgSpecies * kBgPtBins * kCentBins * kBgLevels);\r
- memset(fkBackGroundFactorArray, 0, sizeof(TF1 *) * 12);\r
- memset(fBinLimit, 0, sizeof(Double_t) * (kBgPtBins+1));\r
- memset(&fisppMultiBin, kFALSE, sizeof(fisppMultiBin));\r
- memset(fCentralityLimits, 0, sizeof(Float_t) * 12);\r
-\r
- SetppAnalysis();\r
-}\r
-\r
-//____________________________________________________________\r
-AliAnalysisTaskHFE::AliAnalysisTaskHFE(const char * name):\r
- AliAnalysisTaskSE(name)\r
- , fAODMCHeader(NULL)\r
- , fAODArrayMCInfo(NULL)\r
- , fQAlevel(0)\r
- , fPlugins(0)\r
- , fCollisionSystem(3)\r
- , fFillSignalOnly(kTRUE)\r
- , fFillNoCuts(kFALSE)\r
- , fApplyCutAOD(kFALSE)\r
- , fBackGroundFactorApply(kFALSE)\r
- , fRemovePileUp(kFALSE)\r
- , fIdentifiedAsPileUp(kFALSE)\r
- , fIdentifiedAsOutInz(kFALSE)\r
- , fPassTheEventCut(kFALSE) \r
- , fRejectKinkMother(kTRUE)\r
- , fisppMultiBin(kFALSE)\r
- , fPbPbUserCentralityBinning(kFALSE)\r
- , fRemoveFirstEvent(kFALSE)\r
- , fisNonHFEsystematics(kFALSE)\r
- , fSpecialTrigger(NULL)\r
- , fCentralityF(-1)\r
- , fCentralityPercent(-1)\r
- , fCentralityEstimator("V0M")\r
- , fContributors(0.5)\r
- , fWeightBackGround(0.)\r
- , fVz(0.0)\r
- , fContainer(NULL)\r
- , fVarManager(NULL)\r
- , fSignalCuts(NULL)\r
- , fCFM(NULL)\r
- , fTriggerAnalysis(NULL)\r
- , fPID(NULL)\r
- , fPIDqa(NULL)\r
- , fPIDpreselect(NULL)\r
- , fCuts(NULL)\r
- , fTaggedTrackCuts(NULL)\r
- , fCleanTaggedTrack(kFALSE)\r
- , fVariablesTRDTaggedTrack(kFALSE)\r
- , fAnalysisUtils(NULL)\r
- , fCutspreselect(NULL)\r
- , fSecVtx(NULL)\r
- , fElecBackGround(NULL)\r
- , fMCQA(NULL)\r
- , fTaggedTrackAnalysis(NULL)\r
- , fExtraCuts(NULL)\r
- , fBackgroundSubtraction(NULL)\r
- , fTRDTrigger(kFALSE)\r
- , fWhichTRDTrigger(0)\r
- , fQA(NULL)\r
- , fOutput(NULL)\r
- , fHistMCQA(NULL)\r
- , fHistSECVTX(NULL)\r
- , fHistELECBACKGROUND(NULL)\r
- , fQACollection(0x0)\r
-{\r
- //\r
- // Default constructor\r
- // \r
- DefineOutput(1, TList::Class());\r
- DefineOutput(2, TList::Class());\r
-\r
- fPID = new AliHFEpid("hfePid");\r
- fPIDqa = new AliHFEpidQAmanager;\r
- fVarManager = new AliHFEvarManager("hfeVarManager");\r
- fAnalysisUtils = new AliAnalysisUtils;\r
-\r
- memset(fElecBackgroundFactor, 0, sizeof(Double_t) * kElecBgSpecies * kBgPtBins * kCentBins * kBgLevels);\r
- memset(fkBackGroundFactorArray, 0, sizeof(TF1 *) * 12);\r
- memset(fBinLimit, 0, sizeof(Double_t) * (kBgPtBins+1));\r
- memset(&fisppMultiBin, kFALSE, sizeof(fisppMultiBin));\r
- memset(fCentralityLimits, 0, sizeof(Float_t) * 12);\r
-\r
- SetppAnalysis();\r
-}\r
-\r
-//____________________________________________________________\r
-AliAnalysisTaskHFE::AliAnalysisTaskHFE(const AliAnalysisTaskHFE &ref):\r
- AliAnalysisTaskSE(ref)\r
- , fAODMCHeader(NULL)\r
- , fAODArrayMCInfo(NULL)\r
- , fQAlevel(0)\r
- , fPlugins(0)\r
- , fCollisionSystem(ref.fCollisionSystem)\r
- , fFillSignalOnly(ref.fFillSignalOnly)\r
- , fFillNoCuts(ref.fFillNoCuts)\r
- , fApplyCutAOD(ref.fApplyCutAOD)\r
- , fBackGroundFactorApply(ref.fBackGroundFactorApply)\r
- , fRemovePileUp(ref.fRemovePileUp)\r
- , fIdentifiedAsPileUp(ref.fIdentifiedAsPileUp)\r
- , fIdentifiedAsOutInz(ref.fIdentifiedAsOutInz)\r
- , fPassTheEventCut(ref.fPassTheEventCut)\r
- , fRejectKinkMother(ref.fRejectKinkMother)\r
- , fisppMultiBin(ref.fisppMultiBin)\r
- , fPbPbUserCentralityBinning(ref.fPbPbUserCentralityBinning)\r
- , fRemoveFirstEvent(ref.fRemoveFirstEvent)\r
- , fisNonHFEsystematics(ref.fisNonHFEsystematics)\r
- , fSpecialTrigger(ref.fSpecialTrigger)\r
- , fCentralityF(ref.fCentralityF)\r
- , fCentralityPercent(ref.fCentralityPercent)\r
- , fCentralityEstimator(ref.fCentralityEstimator)\r
- , fContributors(ref.fContributors)\r
- , fWeightBackGround(ref.fWeightBackGround)\r
- , fVz(ref.fVz)\r
- , fContainer(NULL)\r
- , fVarManager(NULL)\r
- , fSignalCuts(NULL)\r
- , fCFM(NULL)\r
- , fTriggerAnalysis(NULL)\r
- , fPID(NULL)\r
- , fPIDqa(NULL)\r
- , fPIDpreselect(NULL)\r
- , fCuts(NULL)\r
- , fTaggedTrackCuts(NULL)\r
- , fCleanTaggedTrack(ref.fCleanTaggedTrack)\r
- , fVariablesTRDTaggedTrack(ref.fVariablesTRDTaggedTrack)\r
- , fAnalysisUtils(NULL)\r
- , fCutspreselect(NULL)\r
- , fSecVtx(NULL)\r
- , fElecBackGround(NULL)\r
- , fMCQA(NULL)\r
- , fTaggedTrackAnalysis(NULL)\r
- , fExtraCuts(NULL)\r
- , fBackgroundSubtraction(NULL)\r
- , fTRDTrigger(ref.fTRDTrigger)\r
- , fWhichTRDTrigger(ref.fWhichTRDTrigger)\r
- , fQA(NULL)\r
- , fOutput(NULL)\r
- , fHistMCQA(NULL)\r
- , fHistSECVTX(NULL)\r
- , fHistELECBACKGROUND(NULL)\r
- , fQACollection(NULL)\r
-{\r
- //\r
- // Copy Constructor\r
- //\r
- ref.Copy(*this);\r
-}\r
-\r
-//____________________________________________________________\r
-AliAnalysisTaskHFE &AliAnalysisTaskHFE::operator=(const AliAnalysisTaskHFE &ref){\r
- //\r
- // Assignment operator\r
- //\r
- if(this == &ref) \r
- ref.Copy(*this);\r
- return *this;\r
-}\r
-\r
-//____________________________________________________________\r
-void AliAnalysisTaskHFE::Copy(TObject &o) const {\r
- // \r
- // Copy into object o\r
- //\r
- AliAnalysisTaskHFE &target = dynamic_cast<AliAnalysisTaskHFE &>(o);\r
- target.fAODMCHeader = fAODMCHeader;\r
- target.fAODArrayMCInfo = fAODArrayMCInfo;\r
- target.fQAlevel = fQAlevel;\r
- target.fPlugins = fPlugins;\r
- target.fCollisionSystem = fCollisionSystem;\r
- target.fFillSignalOnly = fFillSignalOnly;\r
- target.fFillNoCuts = fFillNoCuts;\r
- target.fApplyCutAOD = fApplyCutAOD;\r
- target.fBackGroundFactorApply = fBackGroundFactorApply;\r
- target.fRemovePileUp = fRemovePileUp;\r
- target.fIdentifiedAsPileUp = fIdentifiedAsPileUp;\r
- target.fIdentifiedAsOutInz = fIdentifiedAsOutInz;\r
- target.fPassTheEventCut = fPassTheEventCut;\r
- target.fRejectKinkMother = fRejectKinkMother;\r
- target.fisppMultiBin = fisppMultiBin;\r
- target.fPbPbUserCentralityBinning = fPbPbUserCentralityBinning;\r
- target.fRemoveFirstEvent = fRemoveFirstEvent;\r
- target.fisNonHFEsystematics = fisNonHFEsystematics;\r
- target.fSpecialTrigger = fSpecialTrigger;\r
- target.fCentralityF = fCentralityF;\r
- target.fCentralityPercent = fCentralityPercent;\r
- target.fCentralityEstimator = fCentralityEstimator;\r
- target.fContributors = fContributors;\r
- target.fWeightBackGround = fWeightBackGround;\r
- target.fVz = fVz;\r
- target.fContainer = fContainer;\r
- target.fVarManager = fVarManager;\r
- target.fSignalCuts = fSignalCuts;\r
- target.fCFM = fCFM;\r
- target.fTriggerAnalysis = fTriggerAnalysis;\r
- target.fPID = fPID;\r
- target.fPIDqa = fPIDqa;\r
- target.fPIDpreselect = fPIDpreselect;\r
- target.fCuts = fCuts;\r
- target.fTaggedTrackCuts = fTaggedTrackCuts;\r
- target.fCleanTaggedTrack = fCleanTaggedTrack;\r
- target.fVariablesTRDTaggedTrack = fVariablesTRDTaggedTrack;\r
- target.fAnalysisUtils = fAnalysisUtils;\r
- target.fCutspreselect = fCutspreselect;\r
- target.fSecVtx = fSecVtx;\r
- target.fElecBackGround = fElecBackGround;\r
- target.fMCQA = fMCQA;\r
- target.fTaggedTrackAnalysis = fTaggedTrackAnalysis;\r
- target.fExtraCuts = fExtraCuts;\r
- target.fBackgroundSubtraction = fBackgroundSubtraction;\r
- target.fTRDTrigger = fTRDTrigger;\r
- target.fWhichTRDTrigger = fWhichTRDTrigger;\r
- target.fQA = fQA;\r
- target.fOutput = fOutput;\r
- target.fHistMCQA = fHistMCQA;\r
- target.fHistSECVTX = fHistSECVTX;\r
- target.fHistELECBACKGROUND = fHistELECBACKGROUND;\r
- target.fQACollection = fQACollection;\r
-}\r
-\r
-//____________________________________________________________\r
-AliAnalysisTaskHFE::~AliAnalysisTaskHFE(){\r
- //\r
- // Destructor\r
- //\r
- if(fPID) delete fPID;\r
- if(fPIDpreselect) delete fPIDpreselect;\r
- if(fVarManager) delete fVarManager;\r
- if(fCFM) delete fCFM;\r
- if(fTriggerAnalysis) delete fTriggerAnalysis;\r
- if(fSignalCuts) delete fSignalCuts;\r
- if(fSecVtx) delete fSecVtx;\r
- if(fMCQA) delete fMCQA;\r
- if(fElecBackGround) delete fElecBackGround;\r
- if(fBackgroundSubtraction) delete fBackgroundSubtraction;\r
- if(fSpecialTrigger) delete fSpecialTrigger;\r
- if(fAnalysisUtils) delete fAnalysisUtils;\r
- // Delete output objects only if we are not running in PROOF mode because otherwise this produces a crash during merging\r
- AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();\r
- if(mgr && mgr->GetAnalysisType() != AliAnalysisManager::kProofAnalysis){\r
- if(fPIDqa) delete fPIDqa;\r
- if(fOutput) delete fOutput;\r
- if(fQA) delete fQA;\r
- }\r
-}\r
-\r
-//____________________________________________________________\r
-void AliAnalysisTaskHFE::UserCreateOutputObjects(){\r
- //\r
- // Creating output container and output objects\r
- // Here we also Initialize the correction framework container and \r
- // the objects for\r
- // - PID\r
- // - MC QA\r
- // - SecVtx\r
- // QA histograms are created if requested\r
- // Called once per worker\r
- //\r
- AliDebug(3, "Creating Output Objects");\r
- \r
- // Make lists for Output\r
- if(!fQA) fQA = new TList;\r
- fQA->SetOwner();\r
- if(!fOutput) fOutput = new TList;\r
- fOutput->SetOwner();\r
- \r
- // Automatic determination of the analysis mode\r
- AliVEventHandler *inputHandler = dynamic_cast<AliVEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
- if(!TString(inputHandler->IsA()->GetName()).CompareTo("AliAODInputHandler")){\r
- SetAODAnalysis();\r
- } else {\r
- SetESDAnalysis();\r
- if(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler())\r
- SetHasMCData();\r
- }\r
- printf("Analysis Mode: %s Analysis\n", IsAODanalysis() ? "AOD" : "ESD");\r
- printf("MC Data available %s\n", HasMCData() ? "Yes" : "No");\r
-\r
- // Enable Trigger Analysis\r
- fTriggerAnalysis = new AliTriggerAnalysis;\r
- fTriggerAnalysis->EnableHistograms();\r
- fTriggerAnalysis->SetAnalyzeMC(HasMCData());\r
-\r
- // First Part: Make QA histograms\r
- fQACollection = new AliHFEcollection("TaskQA", "QA histos from the Electron Task");\r
- fQACollection->CreateTH1F("nElectronTracksEvent", "Number of Electron Candidates", 100, 0, 100);\r
- fQACollection->CreateTH1F("nElectron", "Number of electrons", 100, 0, 100);\r
- fQACollection->CreateTH2F("radius", "Production Vertex", 100, 0.0, 5.0, 100, 0.0, 5.0);\r
- fQACollection->CreateTH2F("nTriggerBit2D", "Histo Trigger Bit 2d", 10, 0., 10., 10, 0., 10.,-1);\r
- fQACollection->CreateTH1F("nTriggerBit", "Histo Trigger Bit", 12, 0, 12);\r
- \r
- InitHistoITScluster();\r
- InitContaminationQA();\r
- fQA->Add(fQACollection);\r
-\r
- // Initialize PID\r
- fPID->SetHasMCData(HasMCData());\r
- if(!fPID->GetNumberOfPIDdetectors()) fPID->AddDetector("TPC", 0);\r
- if(IsQAOn(kPIDqa)){\r
- AliInfo("PID QA switched on");\r
- fPIDqa->Initialize(fPID);\r
- fQA->Add(fPIDqa->MakeList("HFEpidQA"));\r
- }\r
- fPID->SortDetectors();\r
-\r
- // Background subtraction-------------------------------------------------------------------\r
- if (GetPlugin(kNonPhotonicElectron)) {\r
- if(!fBackgroundSubtraction) fBackgroundSubtraction = new AliHFENonPhotonicElectron();\r
- if(IsAODanalysis()) fBackgroundSubtraction->SetAOD(kTRUE);\r
- fBackgroundSubtraction->Init();\r
- fOutput->Add(fBackgroundSubtraction->GetListOutput());\r
- }\r
- //------------------------------------------------------------------------------------------\r
-\r
-\r
- // Initialize correction Framework and Cuts\r
- const Int_t kNcutSteps = AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack + AliHFEcuts::kNcutStepsDETrack + AliHFEcuts::kNcutStepsSecvtxTrack;\r
- fCFM = new AliCFManager;\r
- fCFM->SetNStepParticle(kNcutSteps);\r
- MakeParticleContainer();\r
- MakeEventContainer();\r
- // Temporary fix: Initialize particle cuts with NULL\r
- for(Int_t istep = 0; istep < kNcutSteps; istep++)\r
- fCFM->SetParticleCutsList(istep, NULL);\r
- if(!fCuts){\r
- AliWarning("Cuts not available. Default cuts will be used");\r
- fCuts = new AliHFEcuts;\r
- fCuts->CreateStandardCuts();\r
- }\r
- if(IsAODanalysis()) fCuts->SetAOD();\r
- // Make clone for V0 tagging step\r
- fCuts->Initialize(fCFM);\r
- if(fCuts->IsQAOn()) fQA->Add(fCuts->GetQAhistograms());\r
- fSignalCuts = new AliHFEsignalCuts("HFEsignalCuts", "HFE MC Signal definition");\r
- fVarManager->SetSignalCuts(fSignalCuts);\r
- \r
- // add output objects to the List\r
- fOutput->AddAt(fContainer, 0);\r
- fOutput->AddAt(fCFM->GetEventContainer(), 1);\r
- \r
- // mcQA----------------------------------\r
- if (HasMCData() && IsQAOn(kMCqa)) {\r
- AliInfo("MC QA on");\r
- if(!fMCQA) fMCQA = new AliHFEmcQA;\r
- if(!fHistMCQA) fHistMCQA = new TList();\r
- fHistMCQA->SetOwner();\r
- if(IsPbPb()) fMCQA->SetPbPb();\r
- if(fisppMultiBin) fMCQA->SetPPMultiBin();\r
- if(TestBit(kTreeStream)){\r
- fMCQA->EnableDebugStreamer();\r
- }\r
- fMCQA->CreatDefaultHistograms(fHistMCQA);\r
- fMCQA->SetBackgroundWeightFactor(fElecBackgroundFactor[0][0][0],fBinLimit);\r
- fQA->Add(fHistMCQA);\r
- } \r
-\r
- // secvtx----------------------------------\r
- if (GetPlugin(kSecVtx)) {\r
- AliInfo("Secondary Vertex Analysis on");\r
- if(!fSecVtx) fSecVtx = new AliHFEsecVtx;\r
- fSecVtx->SetHasMCData(HasMCData());\r
-\r
- if(!fHistSECVTX) fHistSECVTX = new TList();\r
- fHistSECVTX->SetOwner();\r
- fSecVtx->CreateHistograms(fHistSECVTX);\r
- fOutput->Add(fHistSECVTX);\r
- }\r
-\r
- // background----------------------------------\r
- if (GetPlugin(kIsElecBackGround)) {\r
- AliInfo("Electron BackGround Analysis on");\r
- if(!fElecBackGround){\r
- AliWarning("ElecBackGround not available. Default elecbackground will be used");\r
- fElecBackGround = new AliHFEelecbackground;\r
- }\r
- fElecBackGround->SetHasMCData(HasMCData());\r
-\r
- if(!fHistELECBACKGROUND) fHistELECBACKGROUND = new TList();\r
- fHistELECBACKGROUND->SetOwner();\r
- fElecBackGround->CreateHistograms(fHistELECBACKGROUND);\r
- fOutput->Add(fHistELECBACKGROUND);\r
- } \r
-\r
- // tagged tracks\r
- if(GetPlugin(kTaggedTrackAnalysis)){\r
- AliInfo("Analysis on V0-tagged tracks enabled");\r
- fTaggedTrackAnalysis = new AliHFEtaggedTrackAnalysis(Form("taggedTrackAnalysis%s", GetName()));\r
- fTaggedTrackAnalysis->SetCuts(fTaggedTrackCuts);\r
- fTaggedTrackAnalysis->SetClean(fCleanTaggedTrack);\r
- AliHFEvarManager *varManager = fTaggedTrackAnalysis->GetVarManager();\r
- TObjArray *array = fVarManager->GetVariables();\r
- Int_t nvars = array->GetEntriesFast();\r
- TString namee;\r
- for(Int_t v = 0; v < nvars; v++) {\r
- AliHFEvarManager::AliHFEvariable *variable = (AliHFEvarManager::AliHFEvariable *) array->At(v);\r
- if(!variable) continue;\r
- TString name(((AliHFEvarManager::AliHFEvariable *)variable)->GetName());\r
- if(!name.CompareTo("source")) namee = TString("species");\r
- else namee = TString(name);\r
- Int_t nbins = variable->GetNumberOfBins();\r
- if(variable->HasUserDefinedBinning()){\r
- varManager->AddVariable(namee, nbins, variable->GetBinning());\r
- } else {\r
- varManager->AddVariable(namee, nbins, variable->GetMinimum(), variable->GetMaximum());\r
- }\r
- //printf("For AliTaggedTrackAnalysis, had the variable %s and the one used %s\n",(const char*)variable->GetName(),(const char*) namee);\r
- }\r
- if(fPIDqa->HasHighResolutionHistos()) \r
- fTaggedTrackAnalysis->GetPIDqa()->SetHighResolutionHistos();\r
- fTaggedTrackAnalysis->SetPID(fPID);\r
- fTaggedTrackAnalysis->SetVariablesTRD(fVariablesTRDTaggedTrack);\r
- fTaggedTrackAnalysis->InitContainer();\r
- fOutput->Add(fTaggedTrackAnalysis->GetContainer());\r
- fQA->Add(fTaggedTrackAnalysis->GetPIDQA());\r
- fQA->Add(fTaggedTrackAnalysis->GetCutQA());\r
- fQA->Add(fTaggedTrackAnalysis->GetQAcollection());\r
- }\r
-\r
- //fQA->Print();\r
-\r
- PrintStatus();\r
- // Done!!!\r
- PostData(1, fOutput);\r
- PostData(2, fQA);\r
-}\r
-\r
-//____________________________________________________________\r
-void AliAnalysisTaskHFE::UserExec(Option_t *){\r
- //\r
- // Run the analysis\r
- // \r
-\r
- //printf("test00\n");\r
-\r
- AliDebug(3, "Starting Single Event Analysis");\r
- if(!fInputEvent){\r
- AliError("Reconstructed Event not available");\r
- //printf("Reconstructed Event not available");\r
- return;\r
- }\r
- if(HasMCData() && IsESDanalysis()){\r
- AliDebug(4, Form("MC Event: %p", fMCEvent));\r
- if(!fMCEvent){\r
- AliError("No MC Event, but MC Data required");\r
- //printf("No MC Event, but MC Data required");\r
- return;\r
- }\r
- }\r
- if(!fCuts){\r
- AliError("HFE cuts not available");\r
- //printf("HFE cuts not available");\r
- return;\r
- }\r
- if(!fPID->IsInitialized()){\r
- // Initialize PID with the given run number\r
- fPID->InitializePID(fInputEvent->GetRunNumber());\r
- }\r
-\r
- if(fRemoveFirstEvent){\r
- if(fAnalysisUtils->IsFirstEventInChunk(fInputEvent)) return;\r
- }\r
-\r
- AliESDEvent *ev = dynamic_cast<AliESDEvent *>(fInputEvent);\r
- if(fTRDTrigger)\r
- {\r
- if(!CheckTRDTrigger(ev)) return;\r
- }\r
-\r
-\r
- if(IsESDanalysis() && HasMCData()){\r
- // Protect against missing MC trees\r
- AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());\r
- if(!mcH){ \r
- AliError("No MC Event Handler available");\r
- return;\r
- }\r
- if(!mcH->InitOk()) return;\r
- if(!mcH->TreeK()) return;\r
- if(!mcH->TreeTR()) return;\r
-\r
- // Background subtraction-------------------------------------------------------------------\r
- if(GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->SetMCEvent(fMCEvent);\r
- //------------------------------------------------------------------------------------------\r
- }\r
-\r
- if(IsAODanalysis() && HasMCData()){\r
- // take MC info\r
- AliAODEvent *aodE = dynamic_cast<AliAODEvent *>(fInputEvent);\r
- if(!aodE){ \r
- AliError("No AOD Event");\r
- return;\r
- }\r
- fAODMCHeader = dynamic_cast<AliAODMCHeader *>(fInputEvent->FindListObject(AliAODMCHeader::StdBranchName()));\r
- if(!fAODMCHeader){ \r
- AliError("No AliAODMCHeader");\r
- //printf("No AliAODMCHeader");\r
- return;\r
- }\r
- fAODArrayMCInfo = dynamic_cast<TClonesArray *>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));\r
- if(!fAODArrayMCInfo){ \r
- AliError("No AOD MC particles");\r
- //printf("No AOD MC particles");\r
- return;\r
- }\r
- fSignalCuts->SetMCAODInfo(fAODArrayMCInfo);\r
- // Background subtraction-------------------------------------------------------------------\r
- if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->SetAODArrayMCInfo(fAODArrayMCInfo);\r
- //------------------------------------------------------------------------------------------\r
- }\r
-\r
- //printf("test2\n");\r
-\r
- // need the centrality for everything (MC also)\r
- fCentralityF = -1;\r
- if(!ReadCentrality()) fCentralityF = -1;\r
- //printf("pass centrality\n");\r
- //printf("Reading fCentralityF %d\n",fCentralityF);\r
- \r
- // See if pile up and z in the range\r
- RejectionPileUpVertexRangeEventCut();\r
-\r
- //printf("test3\n");\r
-\r
- // Protect agains missing \r
- if(HasMCData()){\r
- //printf("Has MC data\n");\r
- fSignalCuts->SetMCEvent(fMCEvent);\r
- ProcessMC(); // Run the MC loop + MC QA in case MC Data are available\r
- }\r
- \r
- AliPIDResponse *pidResponse = fInputHandler->GetPIDResponse();\r
- if(!pidResponse){\r
- AliDebug(1, "Using default PID Response");\r
- pidResponse = AliHFEtools::GetDefaultPID(HasMCData(), fInputEvent->IsA() == AliESDEvent::Class());\r
- }\r
- fPID->SetPIDResponse(pidResponse);\r
- if(fPIDpreselect) fPIDpreselect->SetPIDResponse(pidResponse);\r
-\r
- // Background subtraction-------------------------------------------------------------------\r
- if(GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->InitRun(fInputEvent,pidResponse);\r
- //------------------------------------------------------------------------------------------\r
-\r
- // Event loop\r
- if(IsAODanalysis()){\r
- //printf("test4\n");\r
- ProcessAOD();\r
- } else {\r
- const char *specialTrigger = GetSpecialTrigger(fInputEvent->GetRunNumber());\r
- // Check Trigger selection\r
- if(specialTrigger){\r
- AliDebug(2, Form("Special Trigger requested: %s", specialTrigger));\r
- if(!(ev && ev->IsTriggerClassFired(specialTrigger))){\r
- AliDebug(2, "Event not selected"); \r
- return;\r
- } else AliDebug(2, "Event Selected");\r
- } else AliDebug(2, "No Special Trigger requested");\r
- \r
- ProcessESD();\r
- }\r
- // Done!!!\r
- PostData(1, fOutput);\r
- PostData(2, fQA);\r
-}\r
-\r
-//____________________________________________________________\r
-void AliAnalysisTaskHFE::Terminate(Option_t *){\r
- //\r
- // Terminate not implemented at the moment\r
- //\r
-}\r
-\r
-//_______________________________________________________________\r
-Bool_t AliAnalysisTaskHFE::IsEventInBinZero() {\r
- //\r
- //\r
- //\r
-\r
- //printf("test in IsEventInBinZero\n");\r
- if(!fInputEvent){\r
- AliError("Reconstructed Event not available");\r
- return kFALSE;\r
- }\r
-\r
- // check vertex\r
- const AliVVertex *vertex = fInputEvent->GetPrimaryVertex();\r
- if(!vertex) return kTRUE;\r
- //if(vertex) return kTRUE;\r
-\r
- // check tracks\r
- if(fInputEvent->GetNumberOfTracks()<=0) return kTRUE;\r
- //if(fInputEvent->GetNumberOfTracks()>0) return kTRUE;\r
- \r
- \r
- return kFALSE;\r
- \r
-}\r
-//____________________________________________________________\r
-void AliAnalysisTaskHFE::ProcessMC(){\r
- //\r
- // Runs the MC Loop (filling the container for the MC Cut Steps with the observables pt, eta and phi)\r
- // In case MC QA is on also MC QA loop is done\r
- //\r
- AliDebug(3, "Processing MC Information");\r
- Double_t eventContainer [4] = {0., 0., 0., 0.};\r
- if(IsESDanalysis()) eventContainer[0] = fMCEvent->GetPrimaryVertex()->GetZ();\r
- else eventContainer[0] = fAODMCHeader->GetVtxZ();\r
- eventContainer[2] = fCentralityF;\r
- eventContainer[3] = fContributors;\r
- fVz = eventContainer[0];\r
- //printf("z position is %f\n",eventContainer[0]);\r
- //if(fCFM->CheckEventCuts(AliHFEcuts::kEventStepGenerated, fMCEvent)) \r
- fCFM->GetEventContainer()->Fill(eventContainer,AliHFEcuts::kEventStepGenerated);\r
- Int_t nElectrons = 0;\r
- if(IsESDanalysis()){\r
- if(!((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0))){ //kStepMCGeneratedZOutNoPileUpCentralityFine\r
- if (HasMCData() && IsQAOn(kMCqa)) {\r
- AliDebug(2, "Running MC QA");\r
-\r
- if(fMCEvent->Stack()){\r
- fMCQA->SetMCEvent(fMCEvent);\r
- fMCQA->SetGenEventHeader(fMCEvent->GenEventHeader());\r
- fMCQA->SetCentrality(fCentralityF);\r
- fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));\r
- if(IsPbPb()) { fMCQA->SetPbPb();}\r
- else\r
- {\r
- if(fisppMultiBin) fMCQA->SetPPMultiBin();\r
- else fMCQA->SetPP();\r
- }\r
- fMCQA->Init();\r
-\r
- fMCQA->GetMesonKine();\r
-\r
- // loop over all tracks for decayed electrons\r
- for (Int_t igen = 0; igen < fMCEvent->GetNumberOfTracks(); igen++){\r
- TParticle* mcpart = fMCEvent->Stack()->Particle(igen);\r
- if(!mcpart) continue;\r
- fMCQA->GetQuarkKine(mcpart, igen, AliHFEmcQA::kCharm);\r
- fMCQA->GetQuarkKine(mcpart, igen, AliHFEmcQA::kBeauty);\r
- fMCQA->GetHadronKine(mcpart, AliHFEmcQA::kCharm);\r
- fMCQA->GetHadronKine(mcpart, AliHFEmcQA::kBeauty);\r
- fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kCharm, AliHFEmcQA::kElectronPDG); // no accept cut\r
- fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kBeauty, AliHFEmcQA::kElectronPDG); // no accept cut\r
- fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kOthers, AliHFEmcQA::kElectronPDG); // no accept cut\r
- }\r
- //fMCQA->EndOfEventAna(AliHFEmcQA::kCharm);\r
- //fMCQA->EndOfEventAna(AliHFEmcQA::kBeauty);\r
- }\r
-\r
- } // end of MC QA loop\r
- }\r
- // -----------------------------------------------------------------\r
- fCFM->SetMCEventInfo(fMCEvent);\r
- // fCFM->CheckEventCuts(AliCFManager::kEvtRecCuts, fESD);\r
- } else {\r
- fCFM->SetMCEventInfo(fInputEvent);\r
- }\r
- // Run MC loop\r
- AliVParticle *mctrack = NULL;\r
- Int_t numberofmctracks = 0;\r
- if(IsESDanalysis()){\r
- numberofmctracks = fMCEvent->GetNumberOfTracks();\r
- }\r
- else {\r
- numberofmctracks = fAODArrayMCInfo->GetEntriesFast();\r
- }\r
- AliDebug(3, Form("Number of Tracks: %d",numberofmctracks));\r
- //printf("Number of MC track %d\n",numberofmctracks);\r
- for(Int_t imc = 0; imc <numberofmctracks; imc++){\r
- if(IsESDanalysis()) {\r
- if(!(mctrack = fMCEvent->GetTrack(imc))) continue;\r
- }\r
- else {\r
- if(!(mctrack = (AliVParticle *) fAODArrayMCInfo->At(imc))) continue;\r
- }\r
- //printf("Test in ProcessMC\n");\r
- AliDebug(4, "Next MC Track");\r
- if(ProcessMCtrack(mctrack)) nElectrons++;\r
- }\r
-\r
- // fCFM->CheckEventCuts(AliCFManager::kEvtRecCuts, fESD);\r
- fQACollection->Fill("nElectron", nElectrons);\r
-}\r
-\r
-//____________________________________________________________\r
-void AliAnalysisTaskHFE::ProcessESD(){\r
- //\r
- // Run Analysis of reconstructed event in ESD Mode\r
- // Loop over Tracks, filter according cut steps defined in AliHFEcuts\r
- //\r
- AliDebug(1, Form("Task %s", GetName()));\r
- AliDebug(3, "Processing ESD Event");\r
- AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);\r
- if(!fESD){\r
- AliError("ESD Event required for ESD Analysis");\r
- return;\r
- }\r
-\r
- // Set magnetic field if V0 task on\r
- if(fTaggedTrackAnalysis) {\r
- fTaggedTrackAnalysis->SetMagneticField(fESD->GetMagneticField());\r
- fTaggedTrackAnalysis->SetCentrality(fCentralityF);\r
- if(IsHeavyIon()) fTaggedTrackAnalysis->SetPbPb();\r
- else fTaggedTrackAnalysis->SetPP();\r
- }\r
-\r
- // Do event Normalization\r
- Double_t eventContainer[4];\r
- eventContainer[0] = 0.; \r
- if(HasMCData()) eventContainer[0] = fVz;\r
- else {\r
- const AliESDVertex* vtxESD = fESD->GetPrimaryVertex();\r
- if(vtxESD) eventContainer[0] = vtxESD->GetZ();\r
- }\r
- eventContainer[1] = 0.;\r
- eventContainer[2] = fCentralityF;\r
- eventContainer[3] = fContributors;\r
- if(fTriggerAnalysis->IsOfflineTriggerFired(fESD, AliTriggerAnalysis::kV0AND))\r
- eventContainer[1] = 1.;\r
-\r
- //\r
- fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoCut);\r
-\r
- //\r
- if(fIdentifiedAsPileUp) return; \r
- fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoPileUp);\r
-\r
- //\r
- if(TMath::Abs(fCentralityF) < 0) return; \r
- fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecCentralityOk);\r
- //printf("In ProcessESD %f\n",fCentralityF);\r
-\r
- //\r
- if(fIdentifiedAsOutInz) return;\r
- fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepZRange); \r
-\r
- //\r
- if(!fPassTheEventCut) return;\r
- fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepReconstructed);\r
-\r
-\r
- fContainer->NewEvent();\r
-\r
- if (GetPlugin(kIsElecBackGround)) { \r
- fElecBackGround->SetEvent(fESD);\r
- }\r
- if (GetPlugin(kSecVtx)) {\r
- fSecVtx->SetEvent(fESD);\r
- fSecVtx->GetPrimaryCondition();\r
- }\r
-\r
- if(HasMCData()){\r
- if (GetPlugin(kSecVtx)) { \r
- fSecVtx->SetMCEvent(fMCEvent);\r
- fSecVtx->SetMCQA(fMCQA); \r
- }\r
- if (GetPlugin(kIsElecBackGround)) { \r
- fElecBackGround->SetMCEvent(fMCEvent);\r
- }\r
- }\r
-\r
- Double_t container[10];\r
- memset(container, 0, sizeof(Double_t) * 10);\r
- // container for the output THnSparse\r
- Double_t dataDca[6]; // [source, pT, dca, centrality]\r
- Int_t nElectronCandidates = 0;\r
- AliESDtrack *track = NULL, *htrack = NULL;\r
- AliMCParticle *mctrack = NULL;\r
- AliMCParticle *mctrackmother = NULL;\r
-\r
- Bool_t signal = kTRUE;\r
-\r
- fCFM->SetRecEventInfo(fESD);\r
-\r
- // Get Number of contributors to the primary vertex for multiplicity-dependent correction\r
- Int_t ncontribVtx = 0;\r
- const AliESDVertex *priVtx = fESD->GetPrimaryVertexTracks();\r
- if(priVtx){\r
- ncontribVtx = priVtx->GetNContributors();\r
- }\r
-\r
- // minjung for IP QA(temporary ~ 2weeks)\r
- if(!fExtraCuts){\r
- fExtraCuts = new AliHFEextraCuts("hfetmpCuts","HFE tmp Cuts");\r
- }\r
- fExtraCuts->SetRecEventInfo(fESD);\r
-\r
- // Electron background analysis \r
- if (GetPlugin(kIsElecBackGround)) {\r
-\r
- AliDebug(2, "Running BackGround Analysis");\r
-\r
- fElecBackGround->Reset();\r
-\r
- } // end of electron background analysis\r
-\r
-\r
- // Background subtraction-------------------------------------------------------------------\r
- if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent, fCentralityF);\r
- //------------------------------------------------------------------------------------------\r
-\r
- //\r
- // Loop ESD\r
- //\r
- AliDebug(3, Form("Number of Tracks: %d", fESD->GetNumberOfTracks()));\r
- for(Int_t itrack = 0; itrack < fESD->GetNumberOfTracks(); itrack++){\r
- AliDebug(4, "New ESD track");\r
- track = fESD->GetTrack(itrack);\r
- track->SetESDEvent(fESD);\r
-\r
- // fill counts of v0-identified particles\r
- Int_t v0pid = -1;\r
- if(track->TestBit(BIT(14))) v0pid = AliPID::kElectron;\r
- else if(track->TestBit(BIT(15))) v0pid = AliPID::kPion;\r
- else if(track->TestBit(BIT(16))) v0pid = AliPID::kProton;\r
- // here the tagged track analysis will run\r
- if(fTaggedTrackAnalysis && v0pid > -1){ \r
- AliDebug(1, Form("Track identified as %s", AliPID::ParticleName(v0pid)));\r
- fTaggedTrackAnalysis->ProcessTrack(track, v0pid);\r
- AliDebug(1, "V0 PID done");\r
- }\r
- \r
-\r
- //Fill non-HFE source containers at reconstructed events cut step\r
- AliDebug(3, Form("Doing track %d, %p", itrack, track));\r
-\r
-\r
- //////////////////////////////////////\r
- // preselect\r
- //////////////////////////////////////\r
- if(fPIDpreselect || fCutspreselect) {\r
- if(!PreSelectTrack(track)) continue;\r
- }\r
-\r
- signal = kTRUE;\r
- \r
- // Fill step without any cut\r
- \r
- if(HasMCData()){\r
- // Check if it is electrons near the vertex\r
- if(!(mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(track->GetLabel()))))) continue;\r
-\r
- if(fFillSignalOnly && !fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, mctrack)) signal = kFALSE; \r
- else AliDebug(3, "Signal Electron");\r
-\r
- // Fill K pt for Ke3 contributions\r
- if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode())==321)) fQACollection->Fill("Kptspectra",mctrack->Pt());\r
- else if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode())==130)) fQACollection->Fill("K0Lptspectra",mctrack->Pt());\r
- } \r
- // Cache new Track information inside the var manager\r
- fVarManager->NewTrack(track, mctrack, fCentralityF, -1, signal);\r
-\r
- if(fFillNoCuts) {\r
- if(signal || !fFillSignalOnly){\r
- fVarManager->FillContainer(fContainer, "recTrackContReco", AliHFEcuts::kStepRecNoCut, kFALSE);\r
- fVarManager->FillContainer(fContainer, "recTrackContMC", AliHFEcuts::kStepRecNoCut, kTRUE);\r
- }\r
- }\r
- \r
- // RecKine: ITSTPC cuts \r
- if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;\r
- \r
- \r
- // RecPrim\r
- if(fRejectKinkMother) { \r
- if(track->GetKinkIndex(0) != 0) continue; } // Quick and dirty fix to reject both kink mothers and daughters\r
- if(!ProcessCutStep(AliHFEcuts::kStepRecPrim, track)) continue;\r
-\r
- // HFEcuts: ITS layers cuts\r
- if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsITS, track)) continue;\r
- \r
- // HFE cuts: TOF PID and mismatch flag\r
- if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTOF, track)) continue;\r
-\r
- // HFE cuts: TPC PID cleanup\r
- if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTPC, track)) continue;\r
-\r
- // HFEcuts: Nb of tracklets TRD0\r
- if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTRD, track)) continue;\r
-\r
- // Fill correlation maps before PID\r
- if(signal && fContainer->GetCorrelationMatrix("correlationstepbeforePID")) {\r
- //printf("Fill correlation maps before PID\n");\r
- fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepbeforePID"));\r
- }\r
-\r
- if(HasMCData()){\r
- FillProductionVertex(track);\r
-\r
- if(fMCQA && signal){\r
- fMCQA->SetCentrality(fCentralityF);\r
- if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 11)){\r
- Double_t weightElecBgV0[kBgLevels] = {0.,0.,0.};\r
- Double_t hfeimpactRtmp=0., hfeimpactnsigmaRtmp=0.;\r
- fExtraCuts->GetHFEImpactParameters(track, hfeimpactRtmp, hfeimpactnsigmaRtmp);\r
- UChar_t itsPixel = track->GetITSClusterMap();\r
- Double_t ilyrhit=0, ilyrstat=0;\r
- for(Int_t ilyr=0; ilyr<6; ilyr++){\r
- if(TESTBIT(itsPixel, ilyr)) ilyrhit += TMath::Power(2,ilyr);\r
- if(fExtraCuts->CheckITSstatus(fExtraCuts->GetITSstatus(track,ilyr))) ilyrstat += TMath::Power(2,ilyr);\r
- }\r
- fMCQA->SetITSInfo(ilyrhit,ilyrstat);\r
- fMCQA->SetHFEImpactParameters(hfeimpactRtmp, hfeimpactnsigmaRtmp);\r
- fMCQA->SetTrkKine(track->Pt(),track->Eta(), track->Phi());\r
- fMCQA->SetContainerStep(3);\r
- for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){\r
- weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE \r
- if(!fisNonHFEsystematics || IsPbPb())break; \r
- }\r
- \r
- if(fisNonHFEsystematics){\r
- //Fill additional containers for electron source distinction\r
- Int_t elecSource = 0;\r
- elecSource = fMCQA->GetElecSource(mctrack->Particle());\r
- const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};\r
- const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};\r
- Int_t iName = 0;\r
- for(Int_t iSource = AliHFEmcQA::kPi0; iSource <= AliHFEmcQA::kGammaRho0; iSource++){\r
- if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;\r
- if(elecSource == iSource){\r
- for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){\r
- if(weightElecBgV0[iLevel]>0){ \r
- fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 3, kFALSE, weightElecBgV0[iLevel]);\r
- } \r
- else if(weightElecBgV0[iLevel]<0){ \r
- fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 3, kFALSE, -1*weightElecBgV0[iLevel]);\r
- }\r
- if(IsPbPb())break;\r
- }\r
- break;\r
- }\r
- iName++;\r
- if(iName == kElecBgSpecies)iName = 0;\r
- }\r
- }\r
- //else{\r
- if(weightElecBgV0[0]>0) {\r
- fVarManager->FillContainer(fContainer, "conversionElecs", 3, kFALSE, weightElecBgV0[0]);\r
- fVarManager->FillContainer(fContainer, "conversionElecs", 4, kTRUE, weightElecBgV0[0]);\r
- }\r
- else if(weightElecBgV0[0]<0) {\r
- fVarManager->FillContainer(fContainer, "mesonElecs", 3, kFALSE, -1*weightElecBgV0[0]);\r
- fVarManager->FillContainer(fContainer, "mesonElecs", 4, kTRUE, -1*weightElecBgV0[0]);\r
- }\r
- //}\r
- }\r
- }\r
-\r
- Double_t hfeimpactR4all=0., hfeimpactnsigmaR4all=0.;\r
- Int_t sourceDca =-1;\r
- if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 211)){\r
- if(track->Pt()>4.){\r
- fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);\r
- dataDca[0]=0; //pion\r
- dataDca[1]=track->Pt();\r
- dataDca[2]=hfeimpactR4all;\r
- dataDca[3]=fCentralityF;\r
- dataDca[4] = v0pid;\r
- dataDca[5] = double(track->Charge());\r
- fQACollection->Fill("Dca", dataDca);\r
- }\r
- }\r
- else if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 11)){ // to increas statistics for Martin\r
- if(signal){\r
- fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);\r
- if(fSignalCuts->IsCharmElectron(track)){\r
- sourceDca=1;\r
- }\r
- else if(fSignalCuts->IsBeautyElectron(track)){\r
- sourceDca=2;\r
- }\r
- else if(fSignalCuts->IsGammaElectron(track)){\r
- sourceDca=3;\r
- }\r
- else if(fSignalCuts->IsNonHFElectron(track)){\r
- sourceDca=4;\r
- }\r
- else if(fSignalCuts->IsJpsiElectron(track)){\r
- sourceDca=5;\r
- }\r
- else {\r
- sourceDca=6;\r
- }\r
- dataDca[0]=sourceDca;\r
- dataDca[1]=track->Pt();\r
- dataDca[2]=hfeimpactR4all;\r
- dataDca[3]=fCentralityF;\r
- dataDca[4] = v0pid;\r
- dataDca[5] = double(track->Charge());\r
- if(signal) fQACollection->Fill("Dca", dataDca);\r
- }\r
- }\r
- }\r
-\r
- AliHFEpidObject hfetrack;\r
- hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);\r
- hfetrack.SetRecTrack(track);\r
- if(HasMCData()) hfetrack.SetMCTrack(mctrack);\r
- hfetrack.SetCentrality(fCentralityF);\r
- hfetrack.SetMulitplicity(ncontribVtx);\r
- if(IsHeavyIon()) hfetrack.SetPbPb();\r
- else hfetrack.SetPP();\r
- fPID->SetVarManager(fVarManager);\r
- if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue;\r
- nElectronCandidates++;\r
- \r
- // Background subtraction------------------------------------------------------------------------------------------\r
- if (GetPlugin(kNonPhotonicElectron)) {\r
- Int_t indexmother = -1;\r
- Int_t mcsource = -1;\r
- if(HasMCData()){\r
- mcsource = fBackgroundSubtraction->FindMother(mctrack->GetLabel(),indexmother);\r
- }\r
- fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, 1, fCentralityF, -1, mcsource, indexmother);\r
- }\r
- //-----------------------------------------------------------------------------------------------------------------\r
-\r
- // Temporary histogram for chi2/ITS cluster\r
- if(IsPbPb()) {\r
- TBits shared = track->GetTPCSharedMap();\r
- Int_t sharebit=0;\r
- if(shared.CountBits() >= 2) sharebit=1;\r
-\r
- Double_t itschi2percluster = 0.0;\r
- Double_t itsnbcls = static_cast<Double_t>(track->GetNcls(0));\r
- if(itsnbcls > 0) itschi2percluster = track->GetITSchi2()/itsnbcls;\r
-\r
- Double_t itsChi2[7] = {track->Pt(),track->Eta(), track->Phi(),\r
- fCentralityF,track->GetTPCsignalN(), sharebit,itschi2percluster};\r
- fQACollection->Fill("fChi2perITScluster", itsChi2);\r
- }\r
- else{\r
-\r
- Double_t itschi2percluster = 0.0;\r
- Double_t itsnbcls = static_cast<Double_t>(track->GetNcls(0));\r
- if(itsnbcls > 0) itschi2percluster = track->GetITSchi2()/itsnbcls;\r
-\r
- Double_t itsChi2[3] = {track->Pt(), fCentralityF, itschi2percluster};\r
- fQACollection->Fill("fChi2perITScluster", itsChi2);\r
- }\r
-\r
- // Fill Histogram for Hadronic Background\r
- if(HasMCData()){\r
- if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11))\r
- fVarManager->FillContainer(fContainer, "hadronicBackground", UInt_t(0), kFALSE);\r
- else if(mctrack){\r
- // Fill Ke3 contributions\r
- Int_t glabel=TMath::Abs(mctrack->GetMother());\r
- if((mctrackmother = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(glabel)))){\r
- if(TMath::Abs(mctrackmother->Particle()->GetPdgCode())==321)\r
- fQACollection->Fill("Ke3Kecorr",mctrack->Pt(),mctrackmother->Pt());\r
- else if(TMath::Abs(mctrackmother->Particle()->GetPdgCode())==130)\r
- fQACollection->Fill("Ke3K0Lecorr",mctrack->Pt(),mctrackmother->Pt());\r
- }\r
- }\r
- }\r
-\r
- // Fill Containers\r
- if(signal) {\r
- // Apply weight for background contamination\r
- if(fBackGroundFactorApply) {\r
- if(IsHeavyIon() && fCentralityF >= 0) fWeightBackGround = fkBackGroundFactorArray[fCentralityF >= 0 ? fCentralityF : 0]->Eval(TMath::Abs(track->P()));\r
- else fWeightBackGround = fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case\r
-\r
- if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;\r
- else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;\r
- // weightBackGround as special weight\r
- fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, fWeightBackGround);\r
- }\r
- fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterPID"));\r
- }\r
-\r
- Bool_t bTagged=kFALSE;\r
- if(GetPlugin(kSecVtx)) {\r
- AliDebug(2, "Running Secondary Vertex Analysis");\r
- if(fSecVtx->Process(track) && signal) {\r
- fVarManager->FillContainer(fContainer, "recTrackContSecvtxReco", AliHFEcuts::kStepHFEcutsSecvtx, kFALSE);\r
- fVarManager->FillContainer(fContainer, "recTrackContSecvtxMC", AliHFEcuts::kStepHFEcutsSecvtx, kTRUE);\r
- bTagged=kTRUE;\r
- }\r
- }\r
-\r
- // Electron background analysis \r
- if (GetPlugin(kIsElecBackGround)) {\r
- \r
- AliDebug(2, "Running BackGround Analysis");\r
- \r
- for(Int_t jtrack = 0; jtrack < fESD->GetNumberOfTracks(); jtrack++){\r
- htrack = fESD->GetTrack(jtrack);\r
- if ( itrack == jtrack ) continue; \r
- fElecBackGround->PairAnalysis(track, htrack); \r
- }\r
- } // end of electron background analysis\r
-\r
- if (GetPlugin(kDEstep)) { \r
- Double_t weightElecBgV0[kBgLevels] = {0.,0.,0.,};\r
- Int_t elecSource = 0;\r
- Double_t hfeimpactR=0., hfeimpactnsigmaR=0.;\r
- fExtraCuts->GetHFEImpactParameters(track, hfeimpactR, hfeimpactnsigmaR);\r
- if(HasMCData())\r
- {\r
- if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)){\r
- fQACollection->Fill("hadronsBeforeIPcut",track->Pt());\r
- } \r
- if(fMCQA && signal) {\r
- \r
- fMCQA->SetContainerStep(0);\r
- for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){\r
- weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE \r
- if(!fisNonHFEsystematics || IsPbPb())break; \r
- }\r
- \r
- if(fisNonHFEsystematics){\r
- //Fill additional containers for electron source distinction \r
- elecSource = fMCQA->GetElecSource(mctrack->Particle());\r
- const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};\r
- const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};\r
- Int_t iName = 0;\r
- for(Int_t iSource = AliHFEmcQA::kPi0; iSource <= AliHFEmcQA::kGammaRho0; iSource++){\r
- if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;\r
- if(elecSource == iSource){\r
- for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){\r
- if(weightElecBgV0[iLevel]>0) fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 0, kFALSE, weightElecBgV0[iLevel]);\r
- else if(weightElecBgV0[iLevel]<0) fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 0, kFALSE, -1*weightElecBgV0[iLevel]);\r
- if(IsPbPb())break;\r
- }\r
- break;\r
- }\r
- iName++;\r
- if(iName == kElecBgSpecies)iName = 0;\r
- }\r
- }\r
- //else{\r
- if(weightElecBgV0[0]>0) {\r
- fVarManager->FillContainer(fContainer, "conversionElecs", 0, kFALSE, weightElecBgV0[0]);\r
- fVarManager->FillContainer(fContainer, "conversionElecs", 5, kTRUE, weightElecBgV0[0]);\r
- }\r
- else if(weightElecBgV0[0]<0) {\r
- fVarManager->FillContainer(fContainer, "mesonElecs", 0, kFALSE, -1*weightElecBgV0[0]);\r
- fVarManager->FillContainer(fContainer, "mesonElecs", 5, kTRUE, -1*weightElecBgV0[0]);\r
- } \r
- //}\r
- if(bTagged){ // bg estimation for the secondary vertex tagged signals\r
- if(weightElecBgV0[0]>0) fVarManager->FillContainer(fContainer, "conversionElecs", 2, kFALSE, weightElecBgV0[0]);\r
- else if(weightElecBgV0[0]<0) fVarManager->FillContainer(fContainer, "mesonElecs", 2, kFALSE, -1*weightElecBgV0[0]);\r
- }\r
- }\r
- } // end of MC\r
-\r
- dataDca[0]=-1; //for data, don't know the origin\r
- dataDca[1]=track->Pt();\r
- dataDca[2]=hfeimpactR;\r
- dataDca[3]=fCentralityF;\r
- dataDca[4] = v0pid;\r
- dataDca[5] = double(track->Charge());\r
- if (!HasMCData()) fQACollection->Fill("Dca", dataDca);\r
-\r
- // Fill Containers for impact parameter analysis\r
- if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsDca + AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack,track)) continue;\r
- if(signal) {\r
- // Apply weight for background contamination after ip cut\r
- if(fBackGroundFactorApply) {\r
- fWeightBackGround = fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case\r
- if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;\r
- else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;\r
- // weightBackGround as special weight\r
- fVarManager->FillContainer(fContainer, "hadronicBackground", 2, kFALSE, fWeightBackGround);\r
- }\r
- }\r
-\r
- if(HasMCData()){\r
- if(fMCQA && signal) {\r
- fMCQA->SetContainerStep(1);\r
- for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){\r
- weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE \r
- if(!fisNonHFEsystematics || IsPbPb())break; \r
- } \r
- if(fisNonHFEsystematics){\r
- //Fill additional containers for electron source distinction \r
- elecSource = fMCQA->GetElecSource(mctrack->Particle());\r
- const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};\r
- const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};\r
- Int_t iName = 0;\r
- for(Int_t iSource = AliHFEmcQA::kPi0; iSource <= AliHFEmcQA::kGammaRho0; iSource++){\r
- if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;\r
- if(elecSource == iSource){\r
- for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){\r
- if(weightElecBgV0[iLevel]>0) fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 1, kFALSE, weightElecBgV0[iLevel]);\r
- else if(weightElecBgV0[iLevel]<0) fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 1, kFALSE, -1*weightElecBgV0[iLevel]);\r
- if(IsPbPb())break;\r
- }\r
- break;\r
- }\r
- iName++;\r
- if(iName == kElecBgSpecies)iName = 0;\r
- }\r
- }\r
- // else{\r
- if(weightElecBgV0[0]>0) {\r
- fVarManager->FillContainer(fContainer, "conversionElecs", 1, kFALSE, weightElecBgV0[0]);\r
- fVarManager->FillContainer(fContainer, "conversionElecs", 6, kTRUE, weightElecBgV0[0]);\r
- }\r
- else if(weightElecBgV0[0]<0) {\r
- fVarManager->FillContainer(fContainer, "mesonElecs", 1, kFALSE, -1*weightElecBgV0[0]);\r
- fVarManager->FillContainer(fContainer, "mesonElecs", 6, kTRUE, -1*weightElecBgV0[0]);\r
- }\r
- //}\r
- }\r
- }\r
- if(signal) {\r
- fVarManager->FillContainer(fContainer, "recTrackContDEReco", AliHFEcuts::kStepHFEcutsDca, kFALSE);\r
- fVarManager->FillContainer(fContainer, "recTrackContDEMC", AliHFEcuts::kStepHFEcutsDca, kTRUE);\r
- fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterDE"));\r
- }\r
- if(HasMCData()){\r
- if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)){\r
- fQACollection->Fill("hadronsAfterIPcut",track->Pt());\r
- }\r
- }\r
- }\r
-\r
- }\r
-\r
- // Background subtraction-------------------------------------------------------------------\r
- if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->CountPoolAssociated(fInputEvent, fCentralityF);\r
- //------------------------------------------------------------------------------------------\r
-\r
- fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);\r
-}\r
-\r
-//____________________________________________________________\r
-void AliAnalysisTaskHFE::ProcessAOD(){\r
- //\r
- // Run Analysis in AOD Mode\r
- // Function is still in development\r
- //\r
- //printf("Process AOD\n");\r
- AliDebug(3, "Processing AOD Event");\r
- Double_t eventContainer[4];\r
- eventContainer[0] = 0.0;\r
- if(HasMCData()) eventContainer[0] = fVz;\r
- else {\r
- if(fInputEvent->GetPrimaryVertex()) eventContainer[0] = fInputEvent->GetPrimaryVertex()->GetZ();\r
- }\r
- eventContainer[1] = 1.; // No Information available in AOD analysis, assume all events have V0AND\r
- eventContainer[2] = fCentralityF; \r
- eventContainer[3] = fContributors; \r
- \r
- //printf("value event container %f, %f, %f, %f\n",eventContainer[0],eventContainer[1],eventContainer[2],eventContainer[3]);\r
-\r
- AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);\r
- if(!fAOD){\r
- AliError("AOD Event required for AOD Analysis");\r
- return;\r
- }\r
- \r
- //printf("Will fill\n");\r
- //\r
- fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoCut);\r
- //printf("Fill\n");\r
- //\r
- if(fIdentifiedAsPileUp) return; \r
- fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoPileUp);\r
-\r
- //\r
- if(fIdentifiedAsOutInz) return;\r
- fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepZRange); \r
-\r
- //\r
- if(!fPassTheEventCut) return;\r
- fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepReconstructed);\r
- //printf("pass\n");\r
-\r
- fContainer->NewEvent();\r
-\r
- fCFM->SetRecEventInfo(fAOD);\r
-\r
- if(!fExtraCuts){\r
- fExtraCuts = new AliHFEextraCuts("hfeExtraCuts","HFE Extra Cuts");\r
- }\r
- fExtraCuts->SetRecEventInfo(fAOD);\r
-\r
- // Get Number of contributors to the primary vertex for multiplicity-dependent correction\r
- Int_t ncontribVtx = 0;\r
- AliAODVertex *priVtx = fAOD->GetPrimaryVertex();\r
- if(priVtx){\r
- ncontribVtx = priVtx->GetNContributors();\r
- }\r
-\r
- // Look for kink mother\r
- Int_t numberofvertices = fAOD->GetNumberOfVertices();\r
- Double_t listofmotherkink[numberofvertices];\r
- Int_t numberofmotherkink = 0;\r
- for(Int_t ivertex=0; ivertex < numberofvertices; ivertex++) {\r
- AliAODVertex *aodvertex = fAOD->GetVertex(ivertex);\r
- if(!aodvertex) continue;\r
- if(aodvertex->GetType()==AliAODVertex::kKink) {\r
- AliAODTrack *mother = (AliAODTrack *) aodvertex->GetParent();\r
- if(!mother) continue;\r
- Int_t idmother = mother->GetID();\r
- listofmotherkink[numberofmotherkink] = idmother;\r
- //printf("ID %d\n",idmother);\r
- numberofmotherkink++;\r
- }\r
- }\r
- //printf("Number of kink mother in the events %d\n",numberofmotherkink);\r
-\r
- // Background subtraction-------------------------------------------------------------------\r
- if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent, fCentralityF);\r
- //------------------------------------------------------------------------------------------\r
-\r
- // Loop over tracks\r
- AliAODTrack *track = NULL;\r
- AliAODMCParticle *mctrack = NULL;\r
- Double_t dataDca[6]; // [source, pT, dca, centrality]\r
- Int_t nElectronCandidates = 0;\r
- Bool_t signal;\r
-\r
- //printf("Number of track %d\n",(Int_t) fAOD->GetNumberOfTracks());\r
- for(Int_t itrack = 0; itrack < fAOD->GetNumberOfTracks(); itrack++){\r
- track = fAOD->GetTrack(itrack); mctrack = NULL;\r
- if(!track) continue;\r
- \r
- signal = kTRUE;\r
- if(HasMCData()){\r
-\r
- Int_t label = TMath::Abs(track->GetLabel());\r
- if(label && label < fAODArrayMCInfo->GetEntriesFast())\r
- mctrack = dynamic_cast<AliAODMCParticle *>(fAODArrayMCInfo->At(label));\r
- if(fFillSignalOnly && !fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, mctrack)) signal = kFALSE;\r
- }\r
- \r
- fVarManager->NewTrack(track, mctrack, fCentralityF, -1, signal);\r
- \r
- if(fFillNoCuts) {\r
- if(signal || !fFillSignalOnly){\r
- fVarManager->FillContainer(fContainer, "recTrackContReco", AliHFEcuts::kStepRecNoCut, kFALSE);\r
- fVarManager->FillContainer(fContainer, "recTrackContMC", AliHFEcuts::kStepRecNoCut, kTRUE);\r
- }\r
- }\r
-\r
- if(fApplyCutAOD) {\r
- //printf("Apply cuts\n");\r
- // RecKine: ITSTPC cuts \r
- if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;\r
-\r
- // Reject kink mother\r
- if(fRejectKinkMother) {\r
- Bool_t kinkmotherpass = kTRUE;\r
- for(Int_t kinkmother = 0; kinkmother < numberofmotherkink; kinkmother++) {\r
- if(track->GetID() == listofmotherkink[kinkmother]) {\r
- kinkmotherpass = kFALSE;\r
- continue;\r
- }\r
- }\r
- if(!kinkmotherpass) continue;\r
- }\r
- \r
- // RecPrim\r
- if(!ProcessCutStep(AliHFEcuts::kStepRecPrim, track)) continue;\r
- \r
- // HFEcuts: ITS layers cuts\r
- if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsITS, track)) continue;\r
- \r
- // HFE cuts: TOF PID and mismatch flag\r
- if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTOF, track)) continue;\r
- \r
- // HFE cuts: TPC PID cleanup\r
- if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTPC, track)) continue;\r
- \r
- // HFEcuts: Nb of tracklets TRD0\r
- if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTRD, track)) continue;\r
- }\r
-\r
- // Fill correlation maps before PID\r
- if(signal && fContainer->GetCorrelationMatrix("correlationstepbeforePID")) {\r
- //printf("Fill correlation maps before PID\n");\r
- fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepbeforePID"));\r
- }\r
-\r
- if(HasMCData()){\r
- Double_t hfeimpactR4all=0., hfeimpactnsigmaR4all=0.;\r
- Int_t sourceDca =-1;\r
- if(mctrack && (TMath::Abs(mctrack->GetPdgCode()) == 211)){\r
- if(track->Pt()>4.){\r
- fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);\r
- dataDca[0]=0; //pion\r
- dataDca[1]=track->Pt();\r
- dataDca[2]=hfeimpactR4all;\r
- dataDca[3]=fCentralityF;\r
- dataDca[4] = -1; // not store V0 for the moment\r
- dataDca[5] = double(track->Charge());\r
- fQACollection->Fill("Dca", dataDca);\r
- }\r
- }\r
- else if(mctrack && (TMath::Abs(mctrack->GetPdgCode()) == 11)){ // to increas statistics for Martin\r
- if(signal){\r
- fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);\r
- if(fSignalCuts->IsCharmElectron(track)){\r
- sourceDca=1;\r
- }\r
- else if(fSignalCuts->IsBeautyElectron(track)){\r
- sourceDca=2;\r
- }\r
- else if(fSignalCuts->IsGammaElectron(track)){\r
- sourceDca=3;\r
- }\r
- else if(fSignalCuts->IsNonHFElectron(track)){\r
- sourceDca=4;\r
- }\r
- else if(fSignalCuts->IsJpsiElectron(track)){\r
- sourceDca=5;\r
- }\r
- else {\r
- sourceDca=6;\r
- }\r
- dataDca[0]=sourceDca;\r
- dataDca[1]=track->Pt();\r
- dataDca[2]=hfeimpactR4all;\r
- dataDca[3]=fCentralityF;\r
- dataDca[4] = -1; // not store V0 for the moment\r
- dataDca[5] = double(track->Charge());\r
- if(signal) fQACollection->Fill("Dca", dataDca);\r
- }\r
- }\r
- }\r
-\r
- //printf("Will process to PID\n");\r
-\r
- // track accepted, do PID\r
- AliHFEpidObject hfetrack;\r
- hfetrack.SetAnalysisType(AliHFEpidObject::kAODanalysis);\r
- hfetrack.SetRecTrack(track);\r
- if(HasMCData()) hfetrack.SetMCTrack(mctrack);\r
- hfetrack.SetCentrality(fCentralityF);\r
- hfetrack.SetMulitplicity(ncontribVtx); // for correction\r
- if(IsHeavyIon()) hfetrack.SetPbPb();\r
- else hfetrack.SetPP();\r
- fPID->SetVarManager(fVarManager);\r
- if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue; \r
- // we will do PID here as soon as possible\r
-\r
- // Background subtraction----------------------------------------------------------------------------------------------\r
- if (GetPlugin(kNonPhotonicElectron)) {\r
- Int_t indexmother = -1;\r
- Int_t mcsource = -1;\r
- if(HasMCData() && mctrack) mcsource = fBackgroundSubtraction->FindMother(mctrack->GetLabel(),indexmother);\r
- fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, 1, fCentralityF, -1,mcsource, indexmother);\r
- }\r
- //---------------------------------------------------------------------------------------------------------------------\r
-\r
- // end AOD QA\r
- fQACollection->Fill("Filterend", -1); \r
- for(Int_t k=0; k<20; k++) {\r
- Int_t u = 1<<k;\r
- if((track->TestFilterBit(u))) {\r
- fQACollection->Fill("Filterend", k);\r
- }\r
- }\r
- \r
- // Apply weight for background contamination\r
- //Double_t weightBackGround = 1.0;\r
- if(signal) {\r
- // Apply weight for background contamination\r
- if(fBackGroundFactorApply) {\r
- if(IsHeavyIon() && fCentralityF >= 0) fWeightBackGround = fkBackGroundFactorArray[fCentralityF >= 0 ? fCentralityF : 0]->Eval(TMath::Abs(track->P()));\r
- else fWeightBackGround = fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case\r
- \r
- if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;\r
- else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;\r
- // weightBackGround as special weight\r
- fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, fWeightBackGround);\r
- }\r
- fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterPID"));\r
- }\r
- \r
- nElectronCandidates++; \r
-\r
- if (GetPlugin(kDEstep)) {\r
- if (!HasMCData()){\r
- Double_t hfeimpactR=0., hfeimpactnsigmaR=0.;\r
- fExtraCuts->GetHFEImpactParameters(track, hfeimpactR, hfeimpactnsigmaR);\r
- dataDca[0]=-1; //for data, don't know the origin\r
- dataDca[1]=track->Pt();\r
- dataDca[2]=hfeimpactR;\r
- dataDca[3]=fCentralityF;\r
- dataDca[4] = -1; // not store V0 for the moment\r
- dataDca[5] = double(track->Charge());\r
- fQACollection->Fill("Dca", dataDca);\r
- }\r
-\r
- // Fill Containers for impact parameter analysis\r
- if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsDca + AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack,track)) continue;\r
- if(signal) {\r
- // Apply weight for background contamination after ip cut\r
- if(fBackGroundFactorApply) {\r
- fWeightBackGround = fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case\r
- if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;\r
- else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;\r
- // weightBackGround as special weight\r
- fVarManager->FillContainer(fContainer, "hadronicBackground", 2, kFALSE, fWeightBackGround);\r
- }\r
- }\r
- }\r
- }\r
-\r
- // Background subtraction-------------------------------------------------------------------\r
- if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->CountPoolAssociated(fInputEvent, fCentralityF);\r
- //------------------------------------------------------------------------------------------\r
-\r
- fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);\r
-}\r
-\r
-//____________________________________________________________\r
-Bool_t AliAnalysisTaskHFE::ProcessMCtrack(AliVParticle *track){\r
- //\r
- // Filter the Monte Carlo Track\r
- // Additionally Fill a THnSparse for Signal To Background Studies\r
- // Works for AOD and MC analysis Type\r
- //\r
- fVarManager->NewTrack(track, NULL, fCentralityF, -1, kTRUE);\r
-\r
-\r
- Double_t vertex[3] = {0.,0.,0.}; // Production vertex cut to mask gammas which are NOT supposed to have hits in the first ITS layer(s)\r
- if(IsESDanalysis()){\r
- AliMCParticle *mctrack = dynamic_cast<AliMCParticle *>(track);\r
- if(mctrack){\r
- vertex[0] = mctrack->Particle()->Vx();\r
- vertex[1] = mctrack->Particle()->Vy();\r
- }\r
- } else {\r
- AliAODMCParticle *aodmctrack = dynamic_cast<AliAODMCParticle *>(track);\r
- if(aodmctrack) aodmctrack->XvYvZv(vertex);\r
- }\r
-\r
- //printf("MC Generated\n");\r
- if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, track)) return kFALSE;\r
- //printf("MC Generated pass\n");\r
- fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGenerated, kFALSE);\r
-\r
- // Step GeneratedZOutNoPileUp\r
- if((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0)) return kFALSE;\r
- fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGeneratedZOutNoPileUpCentralityFine, kFALSE);\r
- //printf("In ProcessMCtrack %f\n",fCentralityF);\r
-\r
- // Step Generated Event Cut\r
- if(!fPassTheEventCut) return kFALSE;\r
- fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGeneratedEventCut, kFALSE);\r
-\r
- if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCInAcceptance, track)) return kFALSE;\r
- fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCInAcceptance, kFALSE);\r
- return kTRUE;\r
-}\r
-\r
-//____________________________________________________________\r
-Bool_t AliAnalysisTaskHFE::PreSelectTrack(AliESDtrack *track) const {\r
- //\r
- // Preselect tracks\r
- //\r
- \r
-\r
- Bool_t survived = kTRUE;\r
-\r
- if(fCutspreselect) {\r
- //printf("test preselect\n");\r
- if(!fCutspreselect->IsSelected(track)) survived=kFALSE;\r
- }\r
- //printf("survived %d\n",(Int_t)survived);\r
- \r
- if(survived && fPIDpreselect){\r
- // Apply PID\r
- AliHFEpidObject hfetrack;\r
- hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);\r
- hfetrack.SetRecTrack(track);\r
- if(!fPIDpreselect->IsSelected(&hfetrack)) {\r
- //printf("Did not pass AliHFEcuts::kPID\n");\r
- survived = kFALSE;\r
- }\r
- //else printf("Pass AliHFEcuts::kPID\n");\r
- }\r
-\r
- return survived; \r
- \r
-}\r
-//____________________________________________________________\r
-void AliAnalysisTaskHFE::MakeEventContainer(){\r
- //\r
- // Create the event container for the correction framework and link it\r
- // 1st bin: Vertex z-position\r
- // 2nd bin: V0AND decision (normalization to sigma_inel)\r
- // 3rd bin: Centrality class (for pp defined as number of contributors in vertex.)\r
- // 4th bin: Number of contributors > 0\r
- //\r
- \r
- const Int_t kNvar = 4; // number of variables on the grid: \r
- Int_t nBins[kNvar] = {120, 2, 11, 2};\r
- Double_t binMin[kNvar] = {-30. , 0., 0.0, 0.};\r
- Double_t binMax[kNvar] = {30., 2., 11.0, 2.};\r
- \r
- AliCFContainer *evCont = new AliCFContainer("eventContainer", "Container for events", AliHFEcuts::kNcutStepsEvent, kNvar, nBins);\r
- \r
- Double_t *vertexBins = AliHFEtools::MakeLinearBinning(nBins[0], binMin[0], binMax[0]);\r
- Double_t *v0andBins = AliHFEtools::MakeLinearBinning(nBins[1], binMin[1], binMax[1]);\r
- Double_t *centralityBins = AliHFEtools::MakeLinearBinning(nBins[2], binMin[2], binMax[2]);\r
- Double_t *contributorsBins = AliHFEtools::MakeLinearBinning(nBins[3], binMin[3], binMax[3]);\r
- evCont->SetBinLimits(0, vertexBins);\r
- evCont->SetBinLimits(1, v0andBins);\r
- evCont->SetBinLimits(2, centralityBins);\r
- evCont->SetBinLimits(3, contributorsBins);\r
- delete[] vertexBins; delete[] v0andBins; delete[] centralityBins; delete[] contributorsBins;\r
- \r
- fCFM->SetEventContainer(evCont);\r
-}\r
-\r
-//____________________________________________________________\r
-void AliAnalysisTaskHFE::MakeParticleContainer(){\r
- //\r
- // Create the particle container for the correction framework manager and \r
- // link it\r
- //\r
- if(!fContainer) fContainer = new AliHFEcontainer("trackContainer");\r
- fVarManager->DefineVariables(fContainer);\r
-\r
- // Create Correction Framework containers\r
- fContainer->CreateContainer("MCTrackCont", "Track Container filled with MC information", AliHFEcuts::kNcutStepsMCTrack);\r
- fContainer->CreateContainer("recTrackContReco", "Track Container filled with MC information", AliHFEcuts::kNcutStepsRecTrack + fPID->GetNumberOfPIDdetectors());\r
- fContainer->CreateContainer("recTrackContMC", "Track Container filled with MC information", AliHFEcuts::kNcutStepsRecTrack + fPID->GetNumberOfPIDdetectors());\r
- \r
- fContainer->CreateContainer("hadronicBackground", "Container for Hadronic Background", 3);\r
- fContainer->CreateContainer("recTrackContDEReco", "Container for displaced electron analysis with Reco information", 1);\r
- fContainer->CreateContainer("recTrackContDEMC", "Container for displaced electron analysis with MC information", 1);\r
- fContainer->CreateContainer("recTrackContSecvtxReco", "Container for secondary vertexing analysis with Reco information", 1);\r
- fContainer->CreateContainer("recTrackContSecvtxMC", "Container for secondary vertexing analysis with MC information", 1);\r
-\r
- if(HasMCData()){\r
- fContainer->CreateContainer("conversionElecs", "Container for weighted conversion electrons",7);\r
- fContainer->CreateContainer("mesonElecs", "Container for weighted electrons from meson decays",7);\r
- fContainer->Sumw2("conversionElecs");\r
- fContainer->Sumw2("mesonElecs");\r
- \r
- if(fisNonHFEsystematics){\r
- const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};\r
- const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};\r
- for(Int_t iSource = 0; iSource < kElecBgSpecies; iSource++){\r
- for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){\r
- fContainer->CreateContainer(Form("conversionElecs%s%s",sourceName[iSource],levelName[iLevel]), Form("Container for weighted conversion electrons from %s grandm., %s level",sourceName[iSource],levelName[iLevel]),5);\r
- fContainer->CreateContainer(Form("mesonElecs%s%s",sourceName[iSource],levelName[iLevel]), Form("Container for weighted electrons from %s decays, %s level",sourceName[iSource],levelName[iLevel]),5);\r
- fContainer->Sumw2(Form("conversionElecs%s%s",sourceName[iSource],levelName[iLevel]));\r
- fContainer->Sumw2(Form("mesonElecs%s%s",sourceName[iSource],levelName[iLevel]));\r
- if(IsPbPb())break;\r
- }\r
- }\r
- }\r
- //fContainer->CreateContainer("charmElecs", "Container for weighted charm electrons",2);\r
- }\r
-\r
- fContainer->CreateCorrelationMatrix("correlationstepafterPID","THnSparse with correlations");\r
- fContainer->CreateCorrelationMatrix("correlationstepafterDE","THnSparse with correlations");\r
- if(!fVarManager->IsVariableDefined("centrality")) {\r
- //printf("Create the two other correlation maps\n");\r
- fContainer->CreateCorrelationMatrix("correlationstepbeforePID","THnSparse with correlations");\r
- fContainer->CreateCorrelationMatrix("correlationstepafterTOF","THnSparse with correlations");\r
- }\r
-\r
- // Define the step names\r
- for(UInt_t istep = 0; istep < AliHFEcuts::kNcutStepsMCTrack; istep++){\r
- fContainer->SetStepTitle("MCTrackCont", AliHFEcuts::MCCutName(istep), istep);\r
- }\r
- for(UInt_t istep = 0; istep < AliHFEcuts::kNcutStepsRecTrack; istep++){\r
- fContainer->SetStepTitle("recTrackContReco", AliHFEcuts::RecoCutName(istep), istep);\r
- fContainer->SetStepTitle("recTrackContMC", AliHFEcuts::RecoCutName(istep), istep);\r
- }\r
- for(UInt_t ipid = 0; ipid < fPID->GetNumberOfPIDdetectors(); ipid++){\r
- fContainer->SetStepTitle("recTrackContReco", fPID->SortedDetectorName(ipid), AliHFEcuts::kNcutStepsRecTrack + ipid);\r
- fContainer->SetStepTitle("recTrackContMC", fPID->SortedDetectorName(ipid), AliHFEcuts::kNcutStepsRecTrack + ipid);\r
- }\r
-}\r
-//____________________________________________________________\r
-void AliAnalysisTaskHFE::InitContaminationQA(){\r
- // \r
- // Add QA for Impact Parameter cut\r
- //\r
-\r
- TObjArray *array = fVarManager->GetVariables();\r
- Int_t nvars = array->GetEntriesFast();\r
- for(Int_t v = 0; v < nvars; v++) {\r
- AliHFEvarManager::AliHFEvariable *variable = (AliHFEvarManager::AliHFEvariable *) array->At(v);\r
- if(!variable) continue;\r
- TString name(((AliHFEvarManager::AliHFEvariable *)variable)->GetName());\r
- if(!name.CompareTo("pt")) {\r
- const Int_t nBinPt = variable->GetNumberOfBins();\r
- const Double_t *kPtRange = variable->GetBinning();\r
-\r
- fQACollection->CreateTH1Farray("hadronsBeforeIPcut", "Hadrons before IP cut", nBinPt, kPtRange);\r
- fQACollection->CreateTH1Farray("hadronsAfterIPcut", "Hadrons after IP cut", nBinPt, kPtRange);\r
-\r
- fQACollection->CreateTH2Farray("Ke3Kecorr", "Ke3 decay e and K correlation; Ke3K p_{t}; Ke3e p_{t}; ", nBinPt, kPtRange, 20,0.,20.);\r
- fQACollection->CreateTH2Farray("Ke3K0Lecorr", "Ke3 decay e and K0L correlation; Ke3K0L p_{t}; Ke3e p_{t}; ", nBinPt, kPtRange, 20,0.,20.);\r
- fQACollection->CreateTH1Farray("Kptspectra", "Charged Kaons: MC p_{t} ", nBinPt, kPtRange);\r
- fQACollection->CreateTH1Farray("K0Lptspectra", "K0L: MC p_{t} ", nBinPt, kPtRange);\r
-\r
- const Double_t kDCAbound[2] = {-0.2, 0.2};\r
-\r
- const Int_t nDimDca=6;\r
- const Int_t nBinDca[nDimDca] = { 8, nBinPt, 800, 12, 6, 2};\r
- Double_t minimaDca[nDimDca] = { -1., 0., kDCAbound[0], -1., -1, -1.1};\r
- Double_t maximaDca[nDimDca] = { 7., 20., kDCAbound[1], 11., 5, 1.1};\r
-\r
- Double_t *sourceBins = AliHFEtools::MakeLinearBinning(nBinDca[0], minimaDca[0], maximaDca[0]);\r
- Double_t *dcaBins = AliHFEtools::MakeLinearBinning(nBinDca[2], minimaDca[2], maximaDca[2]);\r
- Double_t *centralityBins = AliHFEtools::MakeLinearBinning(nBinDca[3], minimaDca[3], maximaDca[3]);\r
- Double_t *v0PIDBins = AliHFEtools::MakeLinearBinning(nBinDca[4], minimaDca[4], maximaDca[4]);\r
- Double_t *chargeBins = AliHFEtools::MakeLinearBinning(nBinDca[5], minimaDca[5], maximaDca[5]);\r
-\r
- fQACollection->CreateTHnSparseNoLimits("Dca", "Dca; source (0-all, 1-charm,etc); pT [GeV/c]; dca; centrality bin; v0pid; charge", nDimDca, nBinDca);\r
- ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(0, sourceBins);\r
- ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(1, kPtRange);\r
- ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(2, dcaBins);\r
- ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(3, centralityBins);\r
- ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(4, v0PIDBins);\r
- ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(5, chargeBins);\r
-\r
- break;\r
- } \r
- }\r
-\r
-}\r
-\r
-//____________________________________________________________\r
-void AliAnalysisTaskHFE::InitHistoITScluster(){\r
- //\r
- // Initialize a temporary histogram to monitor the chi2/ITS cluster\r
- if(IsPbPb()) {\r
- const Int_t kNDim = 7;\r
- const Int_t kNBins[kNDim] = {88, 20,90,11, 160, 2, 1000};\r
- const Double_t kMin[kNDim] = {0.1, -1,0, 0.,0., 0, 0.};\r
- const Double_t kMax[kNDim] = {20., 1, 2.*TMath::Pi(), 11.,160, 2, 100.};\r
- fQACollection->CreateTHnSparse("fChi2perITScluster", "chi2/ITS cluster; p_{T} (GeV/c);eta;phi; centrality class;nclus;sharebit; #chi^{2}/ITS cluster", kNDim, kNBins, kMin, kMax);\r
- fQACollection->BinLogAxis("fChi2perITScluster", 0);\r
- }\r
- else\r
- {\r
- const Int_t kNDim = 3;\r
- const Int_t kNBins[kNDim] = {44, 11, 1000};\r
- const Double_t kMin[kNDim] = {0.1, 0., 0.};\r
- const Double_t kMax[kNDim] = {20., 11., 100.};\r
- fQACollection->CreateTHnSparse("fChi2perITScluster", "chi2/ITS cluster; p_{T} (GeV/c); centrality class; #chi^{2}/ITS cluster", kNDim, kNBins, kMin, kMax);\r
- fQACollection->BinLogAxis("fChi2perITScluster", 0);\r
- }\r
-}\r
-\r
-//____________________________________________________________\r
-void AliAnalysisTaskHFE::SelectSpecialTrigger(const Char_t *trgclust, Int_t runMin, Int_t runMax){\r
- //\r
- // Select only events triggered by a special trigeer cluster\r
- //\r
- if(!fSpecialTrigger) fSpecialTrigger = new AliOADBContainer("SpecialTrigger");\r
- fSpecialTrigger->AppendObject(new TObjString(trgclust), runMin, runMax);\r
-}\r
-\r
-//____________________________________________________________\r
-const Char_t * AliAnalysisTaskHFE::GetSpecialTrigger(Int_t run){\r
- //\r
- // Derive selected trigger string for given run\r
- //\r
- if(!fSpecialTrigger) return NULL;\r
- TObjString *trg = dynamic_cast<TObjString *>(fSpecialTrigger->GetObject(run));\r
- if(!trg) return NULL;\r
- return trg->String().Data();\r
-}\r
-\r
-//____________________________________________________________\r
-void AliAnalysisTaskHFE::PrintStatus() const {\r
- //\r
- // Print Analysis status\r
- //\r
- printf("\n\tAnalysis Settings\n\t========================================\n\n");\r
- printf("\tSecondary Vertex finding: %s\n", GetPlugin(kSecVtx) ? "YES" : "NO");\r
- printf("\tPrimary Vertex resolution: %s\n", GetPlugin(kPriVtx) ? "YES" : "NO");\r
- printf("\tDisplaced electron analysis step: %s\n", GetPlugin(kDEstep) ? "YES" : "NO");\r
- printf("\tTagged Track Analysis: %s\n", GetPlugin(kTaggedTrackAnalysis) ? "YES" : "NO");\r
- printf("\n");\r
- printf("\tParticle Identification Detectors:\n");\r
- fPID->PrintStatus();\r
- printf("\n");\r
- printf("\tQA: \n");\r
- printf("\t\tPID: %s\n", IsQAOn(kPIDqa) ? "YES" : "NO");\r
- printf("\t\tCUTS: %s\n", (fCuts != NULL && fCuts->IsQAOn()) ? "YES" : "NO");\r
- printf("\t\tMC: %s\n", IsQAOn(kMCqa) ? "YES" : "NO");\r
- printf("\n");\r
-}\r
-\r
-//____________________________________________________________\r
-Bool_t AliAnalysisTaskHFE::FillProductionVertex(const AliVParticle * const track) const{\r
- //\r
- // Find the production vertex of the associated MC track\r
- //\r
- if(!fMCEvent) return kFALSE;\r
- const AliVParticle *mctrack = NULL;\r
- TString objectType = track->IsA()->GetName();\r
- if(objectType.CompareTo("AliESDtrack") == 0 || objectType.CompareTo("AliAODTrack") == 0){\r
- // Reconstructed track\r
- mctrack = fMCEvent->GetTrack(TMath::Abs(track->GetLabel()));\r
- } else {\r
- // MCParticle\r
- mctrack = track;\r
- }\r
-\r
- if(!mctrack) return kFALSE;\r
-\r
- Double_t xv = 0.0;\r
- Double_t yv = 0.0;\r
- \r
- if(TString(mctrack->IsA()->GetName()).CompareTo("AliMCParticle") == 0){\r
- // case MCParticle\r
- const AliMCParticle *mcpart = dynamic_cast<const AliMCParticle *>(mctrack);\r
- if(mcpart){\r
- xv = mcpart->Xv();\r
- yv = mcpart->Yv();\r
- }\r
- } else {\r
- // case AODMCParticle\r
- const AliAODMCParticle *mcpart = dynamic_cast<const AliAODMCParticle *>(mctrack);\r
- if(mcpart){\r
- xv = mcpart->Xv();\r
- yv = mcpart->Yv();\r
- }\r
- }\r
-\r
- //printf("xv %f, yv %f\n",xv,yv);\r
- fQACollection->Fill("radius", TMath::Abs(xv),TMath::Abs(yv));\r
-\r
- return kTRUE;\r
-\r
-}\r
-//__________________________________________\r
-void AliAnalysisTaskHFE::SwitchOnPlugin(Int_t plug){\r
- //\r
- // Switch on Plugin\r
- // Available:\r
- // - Primary vertex studies\r
- // - Secondary vertex Studies\r
- // - Post Processing\r
- //\r
- switch(plug){\r
- case kPriVtx: SETBIT(fPlugins, plug); break;\r
- case kSecVtx: SETBIT(fPlugins, plug); break;\r
- case kIsElecBackGround: SETBIT(fPlugins, plug); break;\r
- case kPostProcess: SETBIT(fPlugins, plug); break;\r
- case kDEstep: SETBIT(fPlugins, plug); break;\r
- case kTaggedTrackAnalysis: SETBIT(fPlugins, plug); break;\r
- case kNonPhotonicElectron: SETBIT(fPlugins, plug); break; \r
- default: AliError("Unknown Plugin");\r
- };\r
-}\r
-//__________________________________________\r
-Bool_t AliAnalysisTaskHFE::ProcessCutStep(Int_t cutStep, AliVParticle *track){\r
- //\r
- // Check single track cuts for a given cut step\r
- // Fill the particle container\r
- //\r
- const Int_t kMCOffset = AliHFEcuts::kNcutStepsMCTrack;\r
- if(!fCFM->CheckParticleCuts(cutStep + kMCOffset, track)) return kFALSE;\r
- if(fVarManager->IsSignalTrack()) {\r
- fVarManager->FillContainer(fContainer, "recTrackContReco", cutStep, kFALSE);\r
- fVarManager->FillContainer(fContainer, "recTrackContMC", cutStep, kTRUE);\r
- }\r
- return kTRUE;\r
-}\r
-//___________________________________________________\r
-Bool_t AliAnalysisTaskHFE::ReadCentrality() {\r
- //\r
- // Recover the centrality of the event from ESD or AOD\r
- //\r
- \r
- Float_t fCentralityLimitstemp[12];\r
- Float_t fCentralityLimitsdefault[12]= {0.,5.,10., 20., 30., 40., 50., 60.,70.,80., 90., 100.};\r
- if(!fPbPbUserCentralityBinning) memcpy(fCentralityLimitstemp,fCentralityLimitsdefault,sizeof(fCentralityLimitsdefault));\r
- else memcpy(fCentralityLimitstemp,fCentralityLimits,sizeof(fCentralityLimitsdefault));\r
- \r
-\r
- Int_t bin = -1;\r
- if(IsHeavyIon()) {\r
- // Centrality\r
- AliCentrality *centrality = fInputEvent->GetCentrality();\r
- fCentralityPercent = centrality->GetCentralityPercentile(fCentralityEstimator.Data());\r
- //printf("centrality %f\n",fCentralityPercent);\r
-\r
- for(Int_t ibin = 0; ibin < 11; ibin++){\r
- if(fCentralityPercent >= fCentralityLimitstemp[ibin] && fCentralityPercent < fCentralityLimitstemp[ibin+1]){\r
- bin = ibin;\r
- //printf("test bin %f, low %f, high %f, %d\n",fCentralityPercent,fCentralityLimitstemp[ibin],fCentralityLimitstemp[ibin+1],ibin);\r
- break;\r
- }\r
- }\r
- \r
- if(bin == -1) bin = 11; // Overflow\r
- } else {\r
- // PP: Tracklet multiplicity, use common definition\r
- Int_t itsMultiplicity = GetITSMultiplicity(fInputEvent);\r
- Int_t multiplicityLimits[8] = {0, 1, 9, 17, 25, 36, 60, 500};\r
- for(Int_t ibin = 0; ibin < 7; ibin++){ \r
- if(itsMultiplicity >= multiplicityLimits[ibin] && itsMultiplicity < multiplicityLimits[ibin + 1]){\r
- bin = ibin;\r
- break;\r
- }\r
- }\r
- if(bin == -1) bin = 7; // Overflow\r
- }\r
- fCentralityF = bin;\r
- AliDebug(2, Form("Centrality class %d\n", fCentralityF));\r
-\r
- \r
- // contributors, to be outsourced\r
- const AliVVertex *vtx;\r
- if(IsAODanalysis()){\r
- AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);\r
- if(!fAOD){\r
- AliError("AOD Event required for AOD Analysis");\r
- return kFALSE;\r
- }\r
- vtx = fAOD->GetPrimaryVertex();\r
- } else {\r
- AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);\r
- if(!fESD){\r
- AliError("ESD Event required for ESD Analysis");\r
- return kFALSE;\r
- }\r
- vtx = fESD->GetPrimaryVertex() ;\r
- }\r
- if(!vtx){ \r
- fContributors = 0.5;\r
- return kFALSE;\r
- }\r
- else {\r
- Int_t contributorstemp = vtx->GetNContributors();\r
- if( contributorstemp <= 0) {\r
- fContributors = 0.5;\r
- //printf("Number of contributors %d and vz %f\n",contributorstemp,vtx->GetZ());\r
- }\r
- else fContributors = 1.5;\r
- //printf("Number of contributors %d\n",contributorstemp);\r
- }\r
- return kTRUE;\r
-}\r
-\r
-//___________________________________________________\r
-Int_t AliAnalysisTaskHFE::GetITSMultiplicity(AliVEvent *ev){\r
- //\r
- // Definition of the Multiplicity according to the JPSI group (F. Kramer)\r
- //\r
- Int_t nTracklets = 0;\r
- Int_t nAcc = 0;\r
- Double_t etaRange = 1.6;\r
-\r
- if (ev->IsA() == AliAODEvent::Class()) {\r
- AliAODTracklets *tracklets = ((AliAODEvent*)ev)->GetTracklets();\r
- nTracklets = tracklets->GetNumberOfTracklets();\r
- for (Int_t nn = 0; nn < nTracklets; nn++) {\r
- Double_t theta = tracklets->GetTheta(nn);\r
- Double_t eta = -TMath::Log(TMath::Tan(theta/2.0));\r
- if (TMath::Abs(eta) < etaRange) nAcc++;\r
- }\r
- } else if (ev->IsA() == AliESDEvent::Class()) {\r
- nTracklets = ((AliESDEvent*)ev)->GetMultiplicity()->GetNumberOfTracklets();\r
- for (Int_t nn = 0; nn < nTracklets; nn++) {\r
- Double_t eta = ((AliESDEvent*)ev)->GetMultiplicity()->GetEta(nn);\r
- if (TMath::Abs(eta) < etaRange) nAcc++;\r
- }\r
- } else return -1;\r
-\r
- return nAcc;\r
-}\r
-\r
-//___________________________________________________\r
-void AliAnalysisTaskHFE::RejectionPileUpVertexRangeEventCut() {\r
- //\r
- // Recover the centrality of the event from ESD or AOD\r
- //\r
- if(IsAODanalysis()){\r
-\r
- AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);\r
- if(!fAOD){\r
- AliError("AOD Event required for AOD Analysis");\r
- return;\r
- }\r
- // PileUp\r
- fIdentifiedAsPileUp = kFALSE;\r
- if(fRemovePileUp && fAOD->IsPileupFromSPD()) fIdentifiedAsPileUp = kTRUE; \r
- // Z vertex\r
- fIdentifiedAsOutInz = kFALSE;\r
- //printf("Z vertex %f and out %f\n",fAOD->GetPrimaryVertex()->GetZ(),fCuts->GetVertexRange());\r
- if(TMath::Abs(fAOD->GetPrimaryVertex()->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE;\r
- // Event Cut\r
- fPassTheEventCut = kTRUE;\r
- if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fAOD)) fPassTheEventCut = kFALSE; \r
- \r
- \r
- } else {\r
- \r
- AliDebug(3, "Processing ESD Centrality");\r
- AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);\r
- if(!fESD){\r
- AliError("ESD Event required for ESD Analysis");\r
- return;\r
- }\r
- // PileUp\r
- fIdentifiedAsPileUp = kFALSE;\r
- if(fRemovePileUp && fESD->IsPileupFromSPD()) fIdentifiedAsPileUp = kTRUE; \r
- \r
-\r
-\r
- // Z vertex\r
- fIdentifiedAsOutInz = kFALSE;\r
- Bool_t findvertex = kTRUE;\r
- const AliESDVertex* vtxESD = fESD->GetPrimaryVertex();\r
- if((!vtxESD) || (vtxESD->GetNContributors() <= 0)) findvertex = kFALSE;\r
- if(findvertex) {\r
- if(TMath::Abs(vtxESD->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE;\r
- }\r
- \r
- //Event Cut\r
- fPassTheEventCut = kTRUE;\r
- if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fESD)) fPassTheEventCut = kFALSE; \r
- \r
- }\r
-\r
-}\r
-//___________________________________________________\r
-Bool_t AliAnalysisTaskHFE::CheckTRDTrigger(AliESDEvent *ev) {\r
- // check function!\r
- // pPb settings\r
-\r
- Bool_t cint8=kFALSE;\r
- Bool_t cint7=kFALSE;\r
- Bool_t cint5=kFALSE;\r
- Bool_t trdtrgevent=kFALSE;\r
-\r
- if(fWhichTRDTrigger==1)\r
- {\r
- // if (!(AliTriggerAnalysis::TRDTrigger(ev) & 0x2)) return; // HSE\r
- cint8= ev->IsTriggerClassFired("CINT8WUHSE-B-NOPF-CENT");\r
- cint7= ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT");\r
- cint5= (ev->IsTriggerClassFired("CINT5WU-B-NOPF-ALL")) &&\r
- (ev->GetHeader()->GetL1TriggerInputs() & (1 << 10));\r
- // printf("trdtrg condition %i \n",fWhichTRDTrigger);\r
- }\r
- if(fWhichTRDTrigger==2)\r
- {\r
- cint8= ev->IsTriggerClassFired("CINT8WUHSE-B-NOPF-CENT");\r
- cint7= ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT");\r
- cint5= (ev->IsTriggerClassFired("CINT5WU-B-NOPF-ALL")) &&\r
- (ev->GetHeader()->GetL1TriggerInputs() & (1 << 10));\r
- // printf("trdtrg condition %i \n",fWhichTRDTrigger);\r
- }\r
-\r
- //HQU\r
- if(fWhichTRDTrigger==3)\r
- {\r
- // if (!(AliTriggerAnalysis::TRDTrigger(ev) & 0x4)) return; // HSE\r
- cint8= ev->IsTriggerClassFired("CINT8WUHQU-B-NOPF-CENT");\r
- cint7= ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT");\r
- cint5= (ev->IsTriggerClassFired("CINT5WU-B-NOPF-ALL")) &&\r
- (ev->GetHeader()->GetL1TriggerInputs() & (1 << 12));\r
- // printf("trdtrg condition %i \n",fWhichTRDTrigger);\r
- }\r
- if(fWhichTRDTrigger==4)\r
- {\r
- cint8= ev->IsTriggerClassFired("CINT8WUHQU-B-NOPF-CENT");\r
- cint7= ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT");\r
- cint5= (ev->IsTriggerClassFired("CINT5WU-B-NOPF-ALL")) &&\r
- (ev->GetHeader()->GetL1TriggerInputs() & (1 << 12));\r
- // printf("trdtrg condition %i \n",fWhichTRDTrigger);\r
- }\r
-\r
- Int_t ntriggerbit=0;\r
- fQACollection->Fill("nTriggerBit",ntriggerbit);\r
- if(ev->IsTriggerClassFired("CINT7-B-NOPF-ALLNOTRD"))\r
- {\r
- ntriggerbit=2;\r
- fQACollection->Fill("nTriggerBit2D",ntriggerbit,ntriggerbit);\r
- fQACollection->Fill("nTriggerBit",ntriggerbit);\r
- }\r
- if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))\r
- {\r
- ntriggerbit=3;\r
- fQACollection->Fill("nTriggerBit2D",ntriggerbit,ntriggerbit);\r
- fQACollection->Fill("nTriggerBit",ntriggerbit);\r
- }\r
- if(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-CENT"))\r
- {\r
- ntriggerbit=4;\r
- fQACollection->Fill("nTriggerBit2D",ntriggerbit,ntriggerbit);\r
- fQACollection->Fill("nTriggerBit",ntriggerbit);\r
- }\r
- if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")) {\r
- ntriggerbit=5;\r
- fQACollection->Fill("nTriggerBit2D",ntriggerbit,ntriggerbit);\r
- fQACollection->Fill("nTriggerBit",ntriggerbit);\r
- if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {\r
- ntriggerbit=11;\r
- fQACollection->Fill("nTriggerBit2D", ntriggerbit,ntriggerbit);\r
- fQACollection->Fill("nTriggerBit",ntriggerbit);\r
- }\r
- }\r
- if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {\r
- ntriggerbit=6;\r
- fQACollection->Fill("nTriggerBit2D", ntriggerbit,ntriggerbit);\r
- fQACollection->Fill("nTriggerBit",ntriggerbit);\r
- if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")) {\r
- ntriggerbit=12;\r
- fQACollection->Fill("nTriggerBit2D",ntriggerbit,ntriggerbit);\r
- fQACollection->Fill("nTriggerBit",ntriggerbit);\r
- }\r
- }\r
- if(ev->IsTriggerClassFired("CEMC7WUHEE-B-NOPF-CENT")) {\r
- ntriggerbit=7;\r
- fQACollection->Fill("nTriggerBit2D", ntriggerbit,ntriggerbit);\r
- fQACollection->Fill("nTriggerBit",ntriggerbit);\r
- }\r
- if(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-FAST")){\r
- ntriggerbit=8;\r
- fQACollection->Fill("nTriggerBit2D", ntriggerbit,ntriggerbit);\r
- fQACollection->Fill("nTriggerBit",ntriggerbit);\r
- }\r
- if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-FAST")){\r
- ntriggerbit=9;\r
- fQACollection->Fill("nTriggerBit2D", ntriggerbit,ntriggerbit);\r
- fQACollection->Fill("nTriggerBit",ntriggerbit);\r
- }\r
- if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-FAST")){\r
- ntriggerbit=10;\r
- fQACollection->Fill("nTriggerBit2D", ntriggerbit,ntriggerbit);\r
- fQACollection->Fill("nTriggerBit",ntriggerbit);\r
- }\r
- if(ntriggerbit==0) fQACollection->Fill("nTriggerBit",1);\r
-\r
-// printf("triggerbit %i \n",ntriggerbit);\r
-\r
- \r
-\r
- if((cint7==kFALSE)&&(cint8==kFALSE)&&(cint5==kFALSE)) trdtrgevent=kFALSE;\r
- else trdtrgevent=kTRUE;\r
-\r
- return trdtrgevent;\r
-\r
-}\r
+/**************************************************************************
+* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+* *
+* Author: The ALICE Off-line Project. *
+* Contributors are mentioned in the code where appropriate. *
+* *
+* Permission to use, copy, modify and distribute this software and its *
+* documentation strictly for non-commercial purposes is hereby granted *
+* without fee, provided that the above copyright notice appears in all *
+* copies and that both the copyright notice and this permission notice *
+* appear in the supporting documentation. The authors make no claims *
+* about the suitability of this software for any purpose. It is *
+* provided "as is" without express or implied warranty. *
+**************************************************************************/
+//
+// The analysis task:
+// Filling an AliCFContainer with the quantities pt, eta and phi
+// for tracks which survivied the particle cuts (MC resp. ESD tracks)
+// Track selection is done using the AliHFE package
+//
+// Author:
+// Raphaelle Bailhache <R.Bailhache@gsi.de>
+// Markus Fasel <M.Fasel@gsi.de>
+// Matus Kalisky <matus.kalisky@cern.ch>
+// MinJung Kweon <minjung@physi.uni-heidelberg.de>
+//
+#include <TAxis.h>
+#include <TBits.h>
+#include <TCanvas.h>
+#include <TChain.h>
+#include <TDirectory.h>
+#include <TFile.h>
+#include <TH3D.h>
+#include <TIterator.h>
+#include <TList.h>
+#include <TLegend.h>
+#include <TMath.h>
+#include <TObjArray.h>
+#include <TObjString.h>
+#include <TParticle.h>
+#include <TProfile.h>
+#include <TString.h>
+#include <TF1.h>
+#include <TTree.h>
+
+#include "AliESDtrackCuts.h"
+#include "AliAnalysisManager.h"
+#include "AliAnalysisUtils.h"
+#include "AliAODInputHandler.h"
+#include "AliAODMCParticle.h"
+#include "AliAODTrack.h"
+#include "AliAODVertex.h"
+#include "AliCentrality.h"
+#include "AliCFContainer.h"
+#include "AliCFManager.h"
+#include "AliESDEvent.h"
+#include "AliESDInputHandler.h"
+#include "AliESDtrack.h"
+#include "AliLog.h"
+#include "AliMCEvent.h"
+#include "AliMCEventHandler.h"
+#include "AliMCParticle.h"
+#include "AliMultiplicity.h"
+#include "AliPID.h"
+#include "AliPIDResponse.h"
+#include "AliOADBContainer.h"
+#include "AliStack.h"
+#include "AliTriggerAnalysis.h"
+#include "AliTRDTriggerAnalysis.h"
+#include "AliVVertex.h"
+
+#include "AliHFEcollection.h"
+#include "AliHFEcontainer.h"
+#include "AliHFEcuts.h"
+#include "AliHFEelecbackground.h"
+#include "AliHFENonPhotonicElectron.h"
+#include "AliHFEmcQA.h"
+#include "AliHFEpairs.h"
+#include "AliHFEpid.h"
+#include "AliHFEpidQAmanager.h"
+#include "AliHFEsecVtxs.h"
+#include "AliHFEsecVtx.h"
+#include "AliHFEsignalCuts.h"
+#include "AliHFEtaggedTrackAnalysis.h"
+#include "AliHFEtools.h"
+#include "AliHFEvarManager.h"
+#include "AliAnalysisTaskHFE.h"
+#include "AliAODMCHeader.h"
+#include "TClonesArray.h"
+
+ClassImp(AliAnalysisTaskHFE)
+
+//____________________________________________________________
+AliAnalysisTaskHFE::AliAnalysisTaskHFE():
+AliAnalysisTaskSE("PID efficiency Analysis")
+ , fAODMCHeader(NULL)
+ , fAODArrayMCInfo(NULL)
+ , fQAlevel(0)
+ , fPlugins(0)
+ , fCollisionSystem(3)
+ , fFillSignalOnly(kTRUE)
+ , fFillNoCuts(kFALSE)
+ , fApplyCutAOD(kFALSE)
+ , fBackGroundFactorApply(kFALSE)
+ , fRemovePileUp(kFALSE)
+ , fIdentifiedAsPileUp(kFALSE)
+ , fIdentifiedAsOutInz(kFALSE)
+ , fPassTheEventCut(kFALSE)
+ , fRejectKinkMother(kTRUE)
+ , fisppMultiBin(kFALSE)
+ , fPbPbUserCentralityBinning(kFALSE)
+ , fRemoveFirstEvent(kFALSE)
+ , fisNonHFEsystematics(kFALSE)
+ , fSpecialTrigger(NULL)
+ , fCentralityF(-1)
+ , fCentralityPercent(-1)
+ , fCentralityEstimator("V0M")
+ , fContributors(0.5)
+ , fWeightBackGround(0.)
+ , fVz(0.0)
+ , fContainer(NULL)
+ , fVarManager(NULL)
+ , fSignalCuts(NULL)
+ , fCFM(NULL)
+ , fTriggerAnalysis(NULL)
+ , fPID(NULL)
+ , fPIDqa(NULL)
+ , fTRDTriggerAnalysis(NULL)
+ , fPIDpreselect(NULL)
+ , fCuts(NULL)
+ , fTaggedTrackCuts(NULL)
+ , fCleanTaggedTrack(kFALSE)
+ , fVariablesTRDTaggedTrack(kFALSE)
+ , fAnalysisUtils(NULL)
+ , fCutspreselect(NULL)
+ , fSecVtx(NULL)
+ , fElecBackGround(NULL)
+ , fMCQA(NULL)
+ , fTaggedTrackAnalysis(NULL)
+ , fExtraCuts(NULL)
+ , fBackgroundSubtraction(NULL)
+ , fTRDTrigger(kFALSE)
+ , fWhichTRDTrigger(0)
+ , fQA(NULL)
+ , fOutput(NULL)
+ , fHistMCQA(NULL)
+ , fHistSECVTX(NULL)
+ , fHistELECBACKGROUND(NULL)
+ , fQACollection(NULL)
+{
+ //
+ // Dummy constructor
+ //
+ memset(fElecBackgroundFactor, 0, sizeof(Double_t) * kElecBgSpecies * kBgPtBins * kCentBins * kBgLevels);
+ memset(fkBackGroundFactorArray, 0, sizeof(TF1 *) * 12);
+ memset(fBinLimit, 0, sizeof(Double_t) * (kBgPtBins+1));
+ memset(&fisppMultiBin, kFALSE, sizeof(fisppMultiBin));
+ memset(fCentralityLimits, 0, sizeof(Float_t) * 12);
+
+ SetppAnalysis();
+}
+
+//____________________________________________________________
+AliAnalysisTaskHFE::AliAnalysisTaskHFE(const char * name):
+ AliAnalysisTaskSE(name)
+ , fAODMCHeader(NULL)
+ , fAODArrayMCInfo(NULL)
+ , fQAlevel(0)
+ , fPlugins(0)
+ , fCollisionSystem(3)
+ , fFillSignalOnly(kTRUE)
+ , fFillNoCuts(kFALSE)
+ , fApplyCutAOD(kFALSE)
+ , fBackGroundFactorApply(kFALSE)
+ , fRemovePileUp(kFALSE)
+ , fIdentifiedAsPileUp(kFALSE)
+ , fIdentifiedAsOutInz(kFALSE)
+ , fPassTheEventCut(kFALSE)
+ , fRejectKinkMother(kTRUE)
+ , fisppMultiBin(kFALSE)
+ , fPbPbUserCentralityBinning(kFALSE)
+ , fRemoveFirstEvent(kFALSE)
+ , fisNonHFEsystematics(kFALSE)
+ , fSpecialTrigger(NULL)
+ , fCentralityF(-1)
+ , fCentralityPercent(-1)
+ , fCentralityEstimator("V0M")
+ , fContributors(0.5)
+ , fWeightBackGround(0.)
+ , fVz(0.0)
+ , fContainer(NULL)
+ , fVarManager(NULL)
+ , fSignalCuts(NULL)
+ , fCFM(NULL)
+ , fTriggerAnalysis(NULL)
+ , fPID(NULL)
+ , fPIDqa(NULL)
+ , fTRDTriggerAnalysis(NULL)
+ , fPIDpreselect(NULL)
+ , fCuts(NULL)
+ , fTaggedTrackCuts(NULL)
+ , fCleanTaggedTrack(kFALSE)
+ , fVariablesTRDTaggedTrack(kFALSE)
+ , fAnalysisUtils(NULL)
+ , fCutspreselect(NULL)
+ , fSecVtx(NULL)
+ , fElecBackGround(NULL)
+ , fMCQA(NULL)
+ , fTaggedTrackAnalysis(NULL)
+ , fExtraCuts(NULL)
+ , fBackgroundSubtraction(NULL)
+ , fTRDTrigger(kFALSE)
+ , fWhichTRDTrigger(0)
+ , fQA(NULL)
+ , fOutput(NULL)
+ , fHistMCQA(NULL)
+ , fHistSECVTX(NULL)
+ , fHistELECBACKGROUND(NULL)
+ , fQACollection(0x0)
+{
+ //
+ // Default constructor
+ //
+ DefineOutput(1, TList::Class());
+ DefineOutput(2, TList::Class());
+
+ fPID = new AliHFEpid("hfePid");
+ fPIDqa = new AliHFEpidQAmanager;
+ fVarManager = new AliHFEvarManager("hfeVarManager");
+ fAnalysisUtils = new AliAnalysisUtils;
+ fTRDTriggerAnalysis = new AliTRDTriggerAnalysis();
+
+ memset(fElecBackgroundFactor, 0, sizeof(Double_t) * kElecBgSpecies * kBgPtBins * kCentBins * kBgLevels);
+ memset(fkBackGroundFactorArray, 0, sizeof(TF1 *) * 12);
+ memset(fBinLimit, 0, sizeof(Double_t) * (kBgPtBins+1));
+ memset(&fisppMultiBin, kFALSE, sizeof(fisppMultiBin));
+ memset(fCentralityLimits, 0, sizeof(Float_t) * 12);
+
+ SetppAnalysis();
+}
+
+//____________________________________________________________
+AliAnalysisTaskHFE::AliAnalysisTaskHFE(const AliAnalysisTaskHFE &ref):
+ AliAnalysisTaskSE(ref)
+ , fAODMCHeader(NULL)
+ , fAODArrayMCInfo(NULL)
+ , fQAlevel(0)
+ , fPlugins(0)
+ , fCollisionSystem(ref.fCollisionSystem)
+ , fFillSignalOnly(ref.fFillSignalOnly)
+ , fFillNoCuts(ref.fFillNoCuts)
+ , fApplyCutAOD(ref.fApplyCutAOD)
+ , fBackGroundFactorApply(ref.fBackGroundFactorApply)
+ , fRemovePileUp(ref.fRemovePileUp)
+ , fIdentifiedAsPileUp(ref.fIdentifiedAsPileUp)
+ , fIdentifiedAsOutInz(ref.fIdentifiedAsOutInz)
+ , fPassTheEventCut(ref.fPassTheEventCut)
+ , fRejectKinkMother(ref.fRejectKinkMother)
+ , fisppMultiBin(ref.fisppMultiBin)
+ , fPbPbUserCentralityBinning(ref.fPbPbUserCentralityBinning)
+ , fRemoveFirstEvent(ref.fRemoveFirstEvent)
+ , fisNonHFEsystematics(ref.fisNonHFEsystematics)
+ , fSpecialTrigger(ref.fSpecialTrigger)
+ , fCentralityF(ref.fCentralityF)
+ , fCentralityPercent(ref.fCentralityPercent)
+ , fCentralityEstimator(ref.fCentralityEstimator)
+ , fContributors(ref.fContributors)
+ , fWeightBackGround(ref.fWeightBackGround)
+ , fVz(ref.fVz)
+ , fContainer(NULL)
+ , fVarManager(NULL)
+ , fSignalCuts(NULL)
+ , fCFM(NULL)
+ , fTriggerAnalysis(NULL)
+ , fPID(NULL)
+ , fPIDqa(NULL)
+ , fTRDTriggerAnalysis(NULL)
+ , fPIDpreselect(NULL)
+ , fCuts(NULL)
+ , fTaggedTrackCuts(NULL)
+ , fCleanTaggedTrack(ref.fCleanTaggedTrack)
+ , fVariablesTRDTaggedTrack(ref.fVariablesTRDTaggedTrack)
+ , fAnalysisUtils(NULL)
+ , fCutspreselect(NULL)
+ , fSecVtx(NULL)
+ , fElecBackGround(NULL)
+ , fMCQA(NULL)
+ , fTaggedTrackAnalysis(NULL)
+ , fExtraCuts(NULL)
+ , fBackgroundSubtraction(NULL)
+ , fTRDTrigger(ref.fTRDTrigger)
+ , fWhichTRDTrigger(ref.fWhichTRDTrigger)
+ , fQA(NULL)
+ , fOutput(NULL)
+ , fHistMCQA(NULL)
+ , fHistSECVTX(NULL)
+ , fHistELECBACKGROUND(NULL)
+ , fQACollection(NULL)
+{
+ //
+ // Copy Constructor
+ //
+ ref.Copy(*this);
+}
+
+//____________________________________________________________
+AliAnalysisTaskHFE &AliAnalysisTaskHFE::operator=(const AliAnalysisTaskHFE &ref){
+ //
+ // Assignment operator
+ //
+ if(this == &ref)
+ ref.Copy(*this);
+ return *this;
+}
+
+//____________________________________________________________
+void AliAnalysisTaskHFE::Copy(TObject &o) const {
+ //
+ // Copy into object o
+ //
+ AliAnalysisTaskHFE &target = dynamic_cast<AliAnalysisTaskHFE &>(o);
+ target.fAODMCHeader = fAODMCHeader;
+ target.fAODArrayMCInfo = fAODArrayMCInfo;
+ target.fQAlevel = fQAlevel;
+ target.fPlugins = fPlugins;
+ target.fCollisionSystem = fCollisionSystem;
+ target.fFillSignalOnly = fFillSignalOnly;
+ target.fFillNoCuts = fFillNoCuts;
+ target.fApplyCutAOD = fApplyCutAOD;
+ target.fBackGroundFactorApply = fBackGroundFactorApply;
+ target.fRemovePileUp = fRemovePileUp;
+ target.fIdentifiedAsPileUp = fIdentifiedAsPileUp;
+ target.fIdentifiedAsOutInz = fIdentifiedAsOutInz;
+ target.fPassTheEventCut = fPassTheEventCut;
+ target.fRejectKinkMother = fRejectKinkMother;
+ target.fisppMultiBin = fisppMultiBin;
+ target.fPbPbUserCentralityBinning = fPbPbUserCentralityBinning;
+ target.fRemoveFirstEvent = fRemoveFirstEvent;
+ target.fisNonHFEsystematics = fisNonHFEsystematics;
+ target.fSpecialTrigger = fSpecialTrigger;
+ target.fCentralityF = fCentralityF;
+ target.fCentralityPercent = fCentralityPercent;
+ target.fCentralityEstimator = fCentralityEstimator;
+ target.fContributors = fContributors;
+ target.fWeightBackGround = fWeightBackGround;
+ target.fVz = fVz;
+ target.fContainer = fContainer;
+ target.fVarManager = fVarManager;
+ target.fSignalCuts = fSignalCuts;
+ target.fCFM = fCFM;
+ target.fTriggerAnalysis = fTriggerAnalysis;
+ target.fPID = fPID;
+ target.fPIDqa = fPIDqa;
+ target.fTRDTriggerAnalysis = fTRDTriggerAnalysis;
+ target.fPIDpreselect = fPIDpreselect;
+ target.fCuts = fCuts;
+ target.fTaggedTrackCuts = fTaggedTrackCuts;
+ target.fCleanTaggedTrack = fCleanTaggedTrack;
+ target.fVariablesTRDTaggedTrack = fVariablesTRDTaggedTrack;
+ target.fAnalysisUtils = fAnalysisUtils;
+ target.fCutspreselect = fCutspreselect;
+ target.fSecVtx = fSecVtx;
+ target.fElecBackGround = fElecBackGround;
+ target.fMCQA = fMCQA;
+ target.fTaggedTrackAnalysis = fTaggedTrackAnalysis;
+ target.fExtraCuts = fExtraCuts;
+ target.fBackgroundSubtraction = fBackgroundSubtraction;
+ target.fTRDTrigger = fTRDTrigger;
+ target.fWhichTRDTrigger = fWhichTRDTrigger;
+ target.fQA = fQA;
+ target.fOutput = fOutput;
+ target.fHistMCQA = fHistMCQA;
+ target.fHistSECVTX = fHistSECVTX;
+ target.fHistELECBACKGROUND = fHistELECBACKGROUND;
+ target.fQACollection = fQACollection;
+}
+
+//____________________________________________________________
+AliAnalysisTaskHFE::~AliAnalysisTaskHFE(){
+ //
+ // Destructor
+ //
+ if(fPID) delete fPID;
+ if(fPIDpreselect) delete fPIDpreselect;
+ if(fVarManager) delete fVarManager;
+ if(fTRDTriggerAnalysis) delete fTRDTriggerAnalysis;
+ if(fCFM) delete fCFM;
+ if(fTriggerAnalysis) delete fTriggerAnalysis;
+ if(fSignalCuts) delete fSignalCuts;
+ if(fSecVtx) delete fSecVtx;
+ if(fMCQA) delete fMCQA;
+ if(fElecBackGround) delete fElecBackGround;
+ if(fBackgroundSubtraction) delete fBackgroundSubtraction;
+ if(fSpecialTrigger) delete fSpecialTrigger;
+ if(fAnalysisUtils) delete fAnalysisUtils;
+ // Delete output objects only if we are not running in PROOF mode because otherwise this produces a crash during merging
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if(mgr && mgr->GetAnalysisType() != AliAnalysisManager::kProofAnalysis){
+ if(fPIDqa) delete fPIDqa;
+ if(fOutput) delete fOutput;
+ if(fQA) delete fQA;
+ }
+}
+
+//____________________________________________________________
+void AliAnalysisTaskHFE::UserCreateOutputObjects(){
+ //
+ // Creating output container and output objects
+ // Here we also Initialize the correction framework container and
+ // the objects for
+ // - PID
+ // - MC QA
+ // - SecVtx
+ // QA histograms are created if requested
+ // Called once per worker
+ //
+ AliDebug(3, "Creating Output Objects");
+
+ // Make lists for Output
+ if(!fQA) fQA = new TList;
+ fQA->SetOwner();
+ if(!fOutput) fOutput = new TList;
+ fOutput->SetOwner();
+
+ // Automatic determination of the analysis mode
+ AliVEventHandler *inputHandler = dynamic_cast<AliVEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
+ if(!TString(inputHandler->IsA()->GetName()).CompareTo("AliAODInputHandler")){
+ SetAODAnalysis();
+ } else {
+ SetESDAnalysis();
+ if(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler())
+ SetHasMCData();
+ }
+ printf("Analysis Mode: %s Analysis\n", IsAODanalysis() ? "AOD" : "ESD");
+ printf("MC Data available %s\n", HasMCData() ? "Yes" : "No");
+
+ // Enable Trigger Analysis
+ fTriggerAnalysis = new AliTriggerAnalysis;
+ fTriggerAnalysis->EnableHistograms();
+ fTriggerAnalysis->SetAnalyzeMC(HasMCData());
+
+ // First Part: Make QA histograms
+ fQACollection = new AliHFEcollection("TaskQA", "QA histos from the Electron Task");
+ fQACollection->CreateTH1F("nElectronTracksEvent", "Number of Electron Candidates", 100, 0, 100);
+ fQACollection->CreateTH1F("nElectron", "Number of electrons", 100, 0, 100);
+ fQACollection->CreateTH2F("radius", "Production Vertex", 100, 0.0, 5.0, 100, 0.0, 5.0);
+ fQACollection->CreateTH1F("nTriggerBit", "Histo Trigger Bit", 22, 0, 22);
+
+ InitHistoITScluster();
+ InitContaminationQA();
+ fQA->Add(fQACollection);
+
+ // Initialize PID
+ fPID->SetHasMCData(HasMCData());
+ if(!fPID->GetNumberOfPIDdetectors()) fPID->AddDetector("TPC", 0);
+ if(IsQAOn(kPIDqa)){
+ AliInfo("PID QA switched on");
+ fPIDqa->Initialize(fPID);
+ fQA->Add(fPIDqa->MakeList("HFEpidQA"));
+ }
+ fPID->SortDetectors();
+
+ // Background subtraction-------------------------------------------------------------------
+ if (GetPlugin(kNonPhotonicElectron)) {
+ if(!fBackgroundSubtraction) fBackgroundSubtraction = new AliHFENonPhotonicElectron();
+ if(IsAODanalysis()) fBackgroundSubtraction->SetAOD(kTRUE);
+ fBackgroundSubtraction->Init();
+ fOutput->Add(fBackgroundSubtraction->GetListOutput());
+ }
+ //------------------------------------------------------------------------------------------
+
+
+ // Initialize correction Framework and Cuts
+ const Int_t kNcutSteps = AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack + AliHFEcuts::kNcutStepsDETrack + AliHFEcuts::kNcutStepsSecvtxTrack;
+ fCFM = new AliCFManager;
+ fCFM->SetNStepParticle(kNcutSteps);
+ MakeParticleContainer();
+ MakeEventContainer();
+ // Temporary fix: Initialize particle cuts with NULL
+ for(Int_t istep = 0; istep < kNcutSteps; istep++)
+ fCFM->SetParticleCutsList(istep, NULL);
+ if(!fCuts){
+ AliWarning("Cuts not available. Default cuts will be used");
+ fCuts = new AliHFEcuts;
+ fCuts->CreateStandardCuts();
+ }
+ if(IsAODanalysis()) fCuts->SetAOD();
+ // Make clone for V0 tagging step
+ fCuts->Initialize(fCFM);
+ if(fCuts->IsQAOn()) fQA->Add(fCuts->GetQAhistograms());
+ fSignalCuts = new AliHFEsignalCuts("HFEsignalCuts", "HFE MC Signal definition");
+ fVarManager->SetSignalCuts(fSignalCuts);
+
+ // add output objects to the List
+ fOutput->AddAt(fContainer, 0);
+ fOutput->AddAt(fCFM->GetEventContainer(), 1);
+
+ // mcQA----------------------------------
+ if (HasMCData() && IsQAOn(kMCqa)) {
+ AliInfo("MC QA on");
+ if(!fMCQA) fMCQA = new AliHFEmcQA;
+ if(!fHistMCQA) fHistMCQA = new TList();
+ fHistMCQA->SetOwner();
+ if(IsPbPb()) fMCQA->SetPbPb();
+ if(fisppMultiBin) fMCQA->SetPPMultiBin();
+ if(TestBit(kTreeStream)){
+ fMCQA->EnableDebugStreamer();
+ }
+ fMCQA->CreatDefaultHistograms(fHistMCQA);
+ fMCQA->SetBackgroundWeightFactor(fElecBackgroundFactor[0][0][0],fBinLimit);
+ fQA->Add(fHistMCQA);
+ }
+
+ // secvtx----------------------------------
+ if (GetPlugin(kSecVtx)) {
+ AliInfo("Secondary Vertex Analysis on");
+ if(!fSecVtx) fSecVtx = new AliHFEsecVtx;
+ fSecVtx->SetHasMCData(HasMCData());
+
+ if(!fHistSECVTX) fHistSECVTX = new TList();
+ fHistSECVTX->SetOwner();
+ fSecVtx->CreateHistograms(fHistSECVTX);
+ fOutput->Add(fHistSECVTX);
+ }
+
+ // background----------------------------------
+ if (GetPlugin(kIsElecBackGround)) {
+ AliInfo("Electron BackGround Analysis on");
+ if(!fElecBackGround){
+ AliWarning("ElecBackGround not available. Default elecbackground will be used");
+ fElecBackGround = new AliHFEelecbackground;
+ }
+ fElecBackGround->SetHasMCData(HasMCData());
+
+ if(!fHistELECBACKGROUND) fHistELECBACKGROUND = new TList();
+ fHistELECBACKGROUND->SetOwner();
+ fElecBackGround->CreateHistograms(fHistELECBACKGROUND);
+ fOutput->Add(fHistELECBACKGROUND);
+ }
+
+ // tagged tracks
+ if(GetPlugin(kTaggedTrackAnalysis)){
+ AliInfo("Analysis on V0-tagged tracks enabled");
+ fTaggedTrackAnalysis = new AliHFEtaggedTrackAnalysis(Form("taggedTrackAnalysis%s", GetName()));
+ fTaggedTrackAnalysis->SetCuts(fTaggedTrackCuts);
+ fTaggedTrackAnalysis->SetClean(fCleanTaggedTrack);
+ AliHFEvarManager *varManager = fTaggedTrackAnalysis->GetVarManager();
+ TObjArray *array = fVarManager->GetVariables();
+ Int_t nvars = array->GetEntriesFast();
+ TString namee;
+ for(Int_t v = 0; v < nvars; v++) {
+ AliHFEvarManager::AliHFEvariable *variable = (AliHFEvarManager::AliHFEvariable *) array->At(v);
+ if(!variable) continue;
+ TString name(((AliHFEvarManager::AliHFEvariable *)variable)->GetName());
+ if(!name.CompareTo("source")) namee = TString("species");
+ else namee = TString(name);
+ Int_t nbins = variable->GetNumberOfBins();
+ if(variable->HasUserDefinedBinning()){
+ varManager->AddVariable(namee, nbins, variable->GetBinning());
+ } else {
+ varManager->AddVariable(namee, nbins, variable->GetMinimum(), variable->GetMaximum());
+ }
+ //printf("For AliTaggedTrackAnalysis, had the variable %s and the one used %s\n",(const char*)variable->GetName(),(const char*) namee);
+ }
+ if(fPIDqa->HasHighResolutionHistos())
+ fTaggedTrackAnalysis->GetPIDqa()->SetHighResolutionHistos();
+ fTaggedTrackAnalysis->SetPID(fPID);
+ fTaggedTrackAnalysis->SetVariablesTRD(fVariablesTRDTaggedTrack);
+ fTaggedTrackAnalysis->InitContainer();
+ fOutput->Add(fTaggedTrackAnalysis->GetContainer());
+ fQA->Add(fTaggedTrackAnalysis->GetPIDQA());
+ fQA->Add(fTaggedTrackAnalysis->GetCutQA());
+ fQA->Add(fTaggedTrackAnalysis->GetQAcollection());
+ }
+
+ //fQA->Print();
+
+ PrintStatus();
+ // Done!!!
+ PostData(1, fOutput);
+ PostData(2, fQA);
+}
+
+//____________________________________________________________
+void AliAnalysisTaskHFE::UserExec(Option_t *){
+ //
+ // Run the analysis
+ //
+
+ //printf("test00\n");
+
+ AliDebug(3, "Starting Single Event Analysis");
+ if(!fInputEvent){
+ AliError("Reconstructed Event not available");
+ //printf("Reconstructed Event not available");
+ return;
+ }
+ if(HasMCData() && IsESDanalysis()){
+ AliDebug(4, Form("MC Event: %p", fMCEvent));
+ if(!fMCEvent){
+ AliError("No MC Event, but MC Data required");
+ //printf("No MC Event, but MC Data required");
+ return;
+ }
+ }
+ if(!fCuts){
+ AliError("HFE cuts not available");
+ //printf("HFE cuts not available");
+ return;
+ }
+ if(!fPID->IsInitialized()){
+ // Initialize PID with the given run number
+ fPID->InitializePID(fInputEvent->GetRunNumber());
+ }
+
+ if(fRemoveFirstEvent){
+ if(fAnalysisUtils->IsFirstEventInChunk(fInputEvent)) return;
+ }
+
+ AliESDEvent *ev = dynamic_cast<AliESDEvent *>(fInputEvent);
+ if(ev && fTRDTrigger)
+ {
+ if(!CheckTRDTrigger(ev)) return;
+ }
+
+
+ if(IsESDanalysis() && HasMCData()){
+ // Protect against missing MC trees
+ AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
+ if(!mcH){
+ AliError("No MC Event Handler available");
+ return;
+ }
+ if(!mcH->InitOk()) return;
+ if(!mcH->TreeK()) return;
+ if(!mcH->TreeTR()) return;
+
+ // Background subtraction-------------------------------------------------------------------
+ if(GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->SetMCEvent(fMCEvent);
+ //------------------------------------------------------------------------------------------
+ }
+
+ if(IsAODanalysis() && HasMCData()){
+ // take MC info
+ AliAODEvent *aodE = dynamic_cast<AliAODEvent *>(fInputEvent);
+ if(!aodE){
+ AliError("No AOD Event");
+ return;
+ }
+ fAODMCHeader = dynamic_cast<AliAODMCHeader *>(fInputEvent->FindListObject(AliAODMCHeader::StdBranchName()));
+ if(!fAODMCHeader){
+ AliError("No AliAODMCHeader");
+ //printf("No AliAODMCHeader");
+ return;
+ }
+ fAODArrayMCInfo = dynamic_cast<TClonesArray *>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
+ if(!fAODArrayMCInfo){
+ AliError("No AOD MC particles");
+ //printf("No AOD MC particles");
+ return;
+ }
+ fSignalCuts->SetMCAODInfo(fAODArrayMCInfo);
+ // Background subtraction-------------------------------------------------------------------
+ if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->SetAODArrayMCInfo(fAODArrayMCInfo);
+ //------------------------------------------------------------------------------------------
+ }
+
+ //printf("test2\n");
+
+ // need the centrality for everything (MC also)
+ fCentralityF = -1;
+ if(!ReadCentrality()) fCentralityF = -1;
+ //printf("pass centrality\n");
+ //printf("Reading fCentralityF %d\n",fCentralityF);
+
+ // See if pile up and z in the range
+ RejectionPileUpVertexRangeEventCut();
+
+ //printf("test3\n");
+
+ // Protect agains missing
+ if(HasMCData()){
+ //printf("Has MC data\n");
+ fSignalCuts->SetMCEvent(fMCEvent);
+ ProcessMC(); // Run the MC loop + MC QA in case MC Data are available
+ }
+
+ AliPIDResponse *pidResponse = fInputHandler->GetPIDResponse();
+ if(!pidResponse){
+ AliDebug(1, "Using default PID Response");
+ pidResponse = AliHFEtools::GetDefaultPID(HasMCData(), fInputEvent->IsA() == AliESDEvent::Class());
+ }
+ fPID->SetPIDResponse(pidResponse);
+ if(fPIDpreselect) fPIDpreselect->SetPIDResponse(pidResponse);
+
+ // Background subtraction-------------------------------------------------------------------
+ if(GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->InitRun(fInputEvent,pidResponse);
+ //------------------------------------------------------------------------------------------
+
+ // Event loop
+ if(IsAODanalysis()){
+ //printf("test4\n");
+ ProcessAOD();
+ } else {
+ const char *specialTrigger = GetSpecialTrigger(fInputEvent->GetRunNumber());
+ // Check Trigger selection
+ if(specialTrigger){
+ AliDebug(2, Form("Special Trigger requested: %s", specialTrigger));
+ if(!(ev && ev->IsTriggerClassFired(specialTrigger))){
+ AliDebug(2, "Event not selected");
+ return;
+ } else AliDebug(2, "Event Selected");
+ } else AliDebug(2, "No Special Trigger requested");
+
+ ProcessESD();
+ }
+ // Done!!!
+ PostData(1, fOutput);
+ PostData(2, fQA);
+}
+
+//____________________________________________________________
+void AliAnalysisTaskHFE::Terminate(Option_t *){
+ //
+ // Terminate not implemented at the moment
+ //
+}
+
+//_______________________________________________________________
+Bool_t AliAnalysisTaskHFE::IsEventInBinZero() {
+ //
+ //
+ //
+
+ //printf("test in IsEventInBinZero\n");
+ if(!fInputEvent){
+ AliError("Reconstructed Event not available");
+ return kFALSE;
+ }
+
+ // check vertex
+ const AliVVertex *vertex = fInputEvent->GetPrimaryVertex();
+ if(!vertex) return kTRUE;
+ //if(vertex) return kTRUE;
+
+ // check tracks
+ if(fInputEvent->GetNumberOfTracks()<=0) return kTRUE;
+ //if(fInputEvent->GetNumberOfTracks()>0) return kTRUE;
+
+
+ return kFALSE;
+
+}
+//____________________________________________________________
+void AliAnalysisTaskHFE::ProcessMC(){
+ //
+ // Runs the MC Loop (filling the container for the MC Cut Steps with the observables pt, eta and phi)
+ // In case MC QA is on also MC QA loop is done
+ //
+ AliDebug(3, "Processing MC Information");
+ Double_t eventContainer [4] = {0., 0., 0., 0.};
+ if(IsESDanalysis()) eventContainer[0] = fMCEvent->GetPrimaryVertex()->GetZ();
+ else eventContainer[0] = fAODMCHeader->GetVtxZ();
+ eventContainer[2] = fCentralityF;
+ eventContainer[3] = fContributors;
+ fVz = eventContainer[0];
+ //printf("z position is %f\n",eventContainer[0]);
+ //if(fCFM->CheckEventCuts(AliHFEcuts::kEventStepGenerated, fMCEvent))
+ fCFM->GetEventContainer()->Fill(eventContainer,AliHFEcuts::kEventStepGenerated);
+ Int_t nElectrons = 0;
+ if(IsESDanalysis()){
+ if(!((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0))){ //kStepMCGeneratedZOutNoPileUpCentralityFine
+ if (HasMCData() && IsQAOn(kMCqa)) {
+ AliDebug(2, "Running MC QA");
+
+ if(fMCEvent->Stack()){
+ fMCQA->SetMCEvent(fMCEvent);
+ fMCQA->SetGenEventHeader(fMCEvent->GenEventHeader());
+ fMCQA->SetCentrality(fCentralityF);
+ fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));
+ if(IsPbPb()) { fMCQA->SetPbPb();}
+ else
+ {
+ if(fisppMultiBin) fMCQA->SetPPMultiBin();
+ else fMCQA->SetPP();
+ }
+ fMCQA->Init();
+
+ fMCQA->GetMesonKine();
+
+ // loop over all tracks for decayed electrons
+ for (Int_t igen = 0; igen < fMCEvent->GetNumberOfTracks(); igen++){
+ TParticle* mcpart = fMCEvent->Stack()->Particle(igen);
+ if(!mcpart) continue;
+ fMCQA->GetQuarkKine(mcpart, igen, AliHFEmcQA::kCharm);
+ fMCQA->GetQuarkKine(mcpart, igen, AliHFEmcQA::kBeauty);
+ fMCQA->GetHadronKine(mcpart, AliHFEmcQA::kCharm);
+ fMCQA->GetHadronKine(mcpart, AliHFEmcQA::kBeauty);
+ fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kCharm, AliHFEmcQA::kElectronPDG); // no accept cut
+ fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kBeauty, AliHFEmcQA::kElectronPDG); // no accept cut
+ fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kOthers, AliHFEmcQA::kElectronPDG); // no accept cut
+ }
+ //fMCQA->EndOfEventAna(AliHFEmcQA::kCharm);
+ //fMCQA->EndOfEventAna(AliHFEmcQA::kBeauty);
+ }
+
+ } // end of MC QA loop
+ }
+ // -----------------------------------------------------------------
+ fCFM->SetMCEventInfo(fMCEvent);
+ // fCFM->CheckEventCuts(AliCFManager::kEvtRecCuts, fESD);
+ } else {
+ fCFM->SetMCEventInfo(fInputEvent);
+ }
+ // Run MC loop
+ AliVParticle *mctrack = NULL;
+ Int_t numberofmctracks = 0;
+ if(IsESDanalysis()){
+ numberofmctracks = fMCEvent->GetNumberOfTracks();
+ }
+ else {
+ numberofmctracks = fAODArrayMCInfo->GetEntriesFast();
+ }
+ AliDebug(3, Form("Number of Tracks: %d",numberofmctracks));
+ //printf("Number of MC track %d\n",numberofmctracks);
+ for(Int_t imc = 0; imc <numberofmctracks; imc++){
+ if(IsESDanalysis()) {
+ if(!(mctrack = fMCEvent->GetTrack(imc))) continue;
+ }
+ else {
+ if(!(mctrack = (AliVParticle *) fAODArrayMCInfo->At(imc))) continue;
+ }
+ //printf("Test in ProcessMC\n");
+ AliDebug(4, "Next MC Track");
+ if(ProcessMCtrack(mctrack)) nElectrons++;
+ }
+
+ // fCFM->CheckEventCuts(AliCFManager::kEvtRecCuts, fESD);
+ fQACollection->Fill("nElectron", nElectrons);
+}
+
+//____________________________________________________________
+void AliAnalysisTaskHFE::ProcessESD(){
+ //
+ // Run Analysis of reconstructed event in ESD Mode
+ // Loop over Tracks, filter according cut steps defined in AliHFEcuts
+ //
+ AliDebug(1, Form("Task %s", GetName()));
+ AliDebug(3, "Processing ESD Event");
+ AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);
+ if(!fESD){
+ AliError("ESD Event required for ESD Analysis");
+ return;
+ }
+
+ // Set magnetic field if V0 task on
+ if(fTaggedTrackAnalysis) {
+ fTaggedTrackAnalysis->SetMagneticField(fESD->GetMagneticField());
+ fTaggedTrackAnalysis->SetCentrality(fCentralityF);
+ if(IsHeavyIon()) fTaggedTrackAnalysis->SetPbPb();
+ else fTaggedTrackAnalysis->SetPP();
+ }
+
+ // Do event Normalization
+ Double_t eventContainer[4];
+ eventContainer[0] = 0.;
+ if(HasMCData()) eventContainer[0] = fVz;
+ else {
+ const AliESDVertex* vtxESD = fESD->GetPrimaryVertex();
+ if(vtxESD) eventContainer[0] = vtxESD->GetZ();
+ }
+ eventContainer[1] = 0.;
+ eventContainer[2] = fCentralityF;
+ eventContainer[3] = fContributors;
+ if(fTriggerAnalysis->IsOfflineTriggerFired(fESD, AliTriggerAnalysis::kV0AND))
+ eventContainer[1] = 1.;
+
+ //
+ fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoCut);
+
+ //
+ if(fIdentifiedAsPileUp) return;
+ fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoPileUp);
+
+ //
+ if(TMath::Abs(fCentralityF) < 0) return;
+ fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecCentralityOk);
+ //printf("In ProcessESD %f\n",fCentralityF);
+
+ //
+ if(fIdentifiedAsOutInz) return;
+ fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepZRange);
+
+ //
+ if(!fPassTheEventCut) return;
+ fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepReconstructed);
+
+
+ fContainer->NewEvent();
+
+ if (GetPlugin(kIsElecBackGround)) {
+ fElecBackGround->SetEvent(fESD);
+ }
+ if (GetPlugin(kSecVtx)) {
+ fSecVtx->SetEvent(fESD);
+ fSecVtx->GetPrimaryCondition();
+ }
+
+ if(HasMCData()){
+ if (GetPlugin(kSecVtx)) {
+ fSecVtx->SetMCEvent(fMCEvent);
+ fSecVtx->SetMCQA(fMCQA);
+ }
+ if (GetPlugin(kIsElecBackGround)) {
+ fElecBackGround->SetMCEvent(fMCEvent);
+ }
+ }
+
+ Double_t container[10];
+ memset(container, 0, sizeof(Double_t) * 10);
+ // container for the output THnSparse
+ Double_t dataDca[6]; // [source, pT, dca, centrality]
+ Int_t nElectronCandidates = 0;
+ AliESDtrack *track = NULL, *htrack = NULL;
+ AliMCParticle *mctrack = NULL;
+ AliMCParticle *mctrackmother = NULL;
+
+ Bool_t signal = kTRUE;
+
+ fCFM->SetRecEventInfo(fESD);
+
+ // Get Number of contributors to the primary vertex for multiplicity-dependent correction
+ Int_t ncontribVtx = 0;
+ const AliESDVertex *priVtx = fESD->GetPrimaryVertexTracks();
+ if(priVtx){
+ ncontribVtx = priVtx->GetNContributors();
+ }
+
+ // minjung for IP QA(temporary ~ 2weeks)
+ if(!fExtraCuts){
+ fExtraCuts = new AliHFEextraCuts("hfetmpCuts","HFE tmp Cuts");
+ }
+ fExtraCuts->SetRecEventInfo(fESD);
+
+ // Electron background analysis
+ if (GetPlugin(kIsElecBackGround)) {
+
+ AliDebug(2, "Running BackGround Analysis");
+
+ fElecBackGround->Reset();
+
+ } // end of electron background analysis
+
+
+ // Background subtraction-------------------------------------------------------------------
+ if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent, fCentralityF);
+ //------------------------------------------------------------------------------------------
+
+ //
+ // Loop ESD
+ //
+ AliDebug(3, Form("Number of Tracks: %d", fESD->GetNumberOfTracks()));
+ for(Int_t itrack = 0; itrack < fESD->GetNumberOfTracks(); itrack++){
+ AliDebug(4, "New ESD track");
+ track = fESD->GetTrack(itrack);
+ track->SetESDEvent(fESD);
+
+ // fill counts of v0-identified particles
+ Int_t v0pid = -1;
+ if(track->TestBit(BIT(14))) v0pid = AliPID::kElectron;
+ else if(track->TestBit(BIT(15))) v0pid = AliPID::kPion;
+ else if(track->TestBit(BIT(16))) v0pid = AliPID::kProton;
+ // here the tagged track analysis will run
+ if(fTaggedTrackAnalysis && v0pid > -1){
+ AliDebug(1, Form("Track identified as %s", AliPID::ParticleName(v0pid)));
+ fTaggedTrackAnalysis->ProcessTrack(track, v0pid);
+ AliDebug(1, "V0 PID done");
+ }
+
+
+ //Fill non-HFE source containers at reconstructed events cut step
+ AliDebug(3, Form("Doing track %d, %p", itrack, track));
+
+
+ //////////////////////////////////////
+ // preselect
+ //////////////////////////////////////
+ if(fPIDpreselect || fCutspreselect) {
+ if(!PreSelectTrack(track)) continue;
+ }
+
+ signal = kTRUE;
+
+ // Fill step without any cut
+
+ if(HasMCData()){
+ // Check if it is electrons near the vertex
+ if(!(mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(track->GetLabel()))))) continue;
+
+ if(fFillSignalOnly && !fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, mctrack)) signal = kFALSE;
+ else AliDebug(3, "Signal Electron");
+
+ // Fill K pt for Ke3 contributions
+ if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode())==321)) fQACollection->Fill("Kptspectra",mctrack->Pt());
+ else if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode())==130)) fQACollection->Fill("K0Lptspectra",mctrack->Pt());
+ }
+ // Cache new Track information inside the var manager
+ fVarManager->NewTrack(track, mctrack, fCentralityF, -1, signal);
+
+ if(fFillNoCuts) {
+ if(signal || !fFillSignalOnly){
+ fVarManager->FillContainer(fContainer, "recTrackContReco", AliHFEcuts::kStepRecNoCut, kFALSE);
+ fVarManager->FillContainer(fContainer, "recTrackContMC", AliHFEcuts::kStepRecNoCut, kTRUE);
+ }
+ }
+
+ // RecKine: ITSTPC cuts
+ if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;
+
+
+ // RecPrim
+ if(fRejectKinkMother) {
+ if(track->GetKinkIndex(0) != 0) continue; } // Quick and dirty fix to reject both kink mothers and daughters
+ if(!ProcessCutStep(AliHFEcuts::kStepRecPrim, track)) continue;
+
+ // HFEcuts: ITS layers cuts
+ if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsITS, track)) continue;
+
+ // HFE cuts: TOF PID and mismatch flag
+ if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTOF, track)) continue;
+
+ // HFE cuts: TPC PID cleanup
+ if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTPC, track)) continue;
+
+ // HFEcuts: Nb of tracklets TRD0
+ if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTRD, track)) continue;
+
+ // Fill correlation maps before PID
+ if(signal && fContainer->GetCorrelationMatrix("correlationstepbeforePID")) {
+ //printf("Fill correlation maps before PID\n");
+ fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepbeforePID"));
+ }
+
+ if(HasMCData()){
+ FillProductionVertex(track);
+
+ if(fMCQA && signal){
+ fMCQA->SetCentrality(fCentralityF);
+ if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 11)){
+ Double_t weightElecBgV0[kBgLevels] = {0.,0.,0.};
+ Double_t hfeimpactRtmp=0., hfeimpactnsigmaRtmp=0.;
+ fExtraCuts->GetHFEImpactParameters(track, hfeimpactRtmp, hfeimpactnsigmaRtmp);
+ UChar_t itsPixel = track->GetITSClusterMap();
+ Double_t ilyrhit=0, ilyrstat=0;
+ for(Int_t ilyr=0; ilyr<6; ilyr++){
+ if(TESTBIT(itsPixel, ilyr)) ilyrhit += TMath::Power(2,ilyr);
+ if(fExtraCuts->CheckITSstatus(fExtraCuts->GetITSstatus(track,ilyr))) ilyrstat += TMath::Power(2,ilyr);
+ }
+ fMCQA->SetITSInfo(ilyrhit,ilyrstat);
+ fMCQA->SetHFEImpactParameters(hfeimpactRtmp, hfeimpactnsigmaRtmp);
+ fMCQA->SetTrkKine(track->Pt(),track->Eta(), track->Phi());
+ fMCQA->SetContainerStep(3);
+ for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
+ weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE
+ if(!fisNonHFEsystematics || IsPbPb())break;
+ }
+
+ if(fisNonHFEsystematics){
+ //Fill additional containers for electron source distinction
+ Int_t elecSource = 0;
+ elecSource = fMCQA->GetElecSource(mctrack->Particle());
+ const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};
+ const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};
+ Int_t iName = 0;
+ for(Int_t iSource = AliHFEmcQA::kPi0; iSource <= AliHFEmcQA::kGammaRho0; iSource++){
+ if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;
+ if(elecSource == iSource){
+ for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
+ if(weightElecBgV0[iLevel]>0){
+ fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 3, kFALSE, weightElecBgV0[iLevel]);
+ }
+ else if(weightElecBgV0[iLevel]<0){
+ fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 3, kFALSE, -1*weightElecBgV0[iLevel]);
+ }
+ if(IsPbPb())break;
+ }
+ break;
+ }
+ iName++;
+ if(iName == kElecBgSpecies)iName = 0;
+ }
+ }
+ //else{
+ if(weightElecBgV0[0]>0) {
+ fVarManager->FillContainer(fContainer, "conversionElecs", 3, kFALSE, weightElecBgV0[0]);
+ fVarManager->FillContainer(fContainer, "conversionElecs", 4, kTRUE, weightElecBgV0[0]);
+ }
+ else if(weightElecBgV0[0]<0) {
+ fVarManager->FillContainer(fContainer, "mesonElecs", 3, kFALSE, -1*weightElecBgV0[0]);
+ fVarManager->FillContainer(fContainer, "mesonElecs", 4, kTRUE, -1*weightElecBgV0[0]);
+ }
+ //}
+ }
+ }
+
+ Double_t hfeimpactR4all=0., hfeimpactnsigmaR4all=0.;
+ Int_t sourceDca =-1;
+ if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 211)){
+ if(track->Pt()>4.){
+ fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);
+ dataDca[0]=0; //pion
+ dataDca[1]=track->Pt();
+ dataDca[2]=hfeimpactR4all;
+ dataDca[3]=fCentralityF;
+ dataDca[4] = v0pid;
+ dataDca[5] = double(track->Charge());
+ fQACollection->Fill("Dca", dataDca);
+ }
+ }
+ else if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 11)){ // to increas statistics for Martin
+ if(signal){
+ fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);
+ if(fSignalCuts->IsCharmElectron(track)){
+ sourceDca=1;
+ }
+ else if(fSignalCuts->IsBeautyElectron(track)){
+ sourceDca=2;
+ }
+ else if(fSignalCuts->IsGammaElectron(track)){
+ sourceDca=3;
+ }
+ else if(fSignalCuts->IsNonHFElectron(track)){
+ sourceDca=4;
+ }
+ else if(fSignalCuts->IsJpsiElectron(track)){
+ sourceDca=5;
+ }
+ else {
+ sourceDca=6;
+ }
+ dataDca[0]=sourceDca;
+ dataDca[1]=track->Pt();
+ dataDca[2]=hfeimpactR4all;
+ dataDca[3]=fCentralityF;
+ dataDca[4] = v0pid;
+ dataDca[5] = double(track->Charge());
+ if(signal) fQACollection->Fill("Dca", dataDca);
+ }
+ }
+ }
+
+ AliHFEpidObject hfetrack;
+ hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);
+ hfetrack.SetRecTrack(track);
+ if(HasMCData()) hfetrack.SetMCTrack(mctrack);
+ hfetrack.SetCentrality(fCentralityF);
+ hfetrack.SetMulitplicity(ncontribVtx);
+ if(IsHeavyIon()) hfetrack.SetPbPb();
+ else hfetrack.SetPP();
+ fPID->SetVarManager(fVarManager);
+ if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue;
+ nElectronCandidates++;
+
+ // Background subtraction------------------------------------------------------------------------------------------
+ if (GetPlugin(kNonPhotonicElectron)) {
+ Int_t indexmother = -1;
+ Int_t mcsource = -1;
+ if(HasMCData()){
+ mcsource = fBackgroundSubtraction->FindMother(mctrack->GetLabel(),indexmother);
+ }
+ fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, 1, fCentralityF, -1, mcsource, indexmother);
+ }
+ //-----------------------------------------------------------------------------------------------------------------
+
+ // Temporary histogram for chi2/ITS cluster
+ if(IsPbPb()) {
+ TBits shared = track->GetTPCSharedMap();
+ Int_t sharebit=0;
+ if(shared.CountBits() >= 2) sharebit=1;
+
+ Double_t itschi2percluster = 0.0;
+ Double_t itsnbcls = static_cast<Double_t>(track->GetNcls(0));
+ if(itsnbcls > 0) itschi2percluster = track->GetITSchi2()/itsnbcls;
+
+ Double_t itsChi2[7] = {track->Pt(),track->Eta(), track->Phi(),
+ static_cast<Double_t>(fCentralityF),static_cast<Double_t>(track->GetTPCsignalN()), static_cast<Double_t>(sharebit),itschi2percluster};
+ fQACollection->Fill("fChi2perITScluster", itsChi2);
+ }
+ else{
+
+ Double_t itschi2percluster = 0.0;
+ Double_t itsnbcls = static_cast<Double_t>(track->GetNcls(0));
+ if(itsnbcls > 0) itschi2percluster = track->GetITSchi2()/itsnbcls;
+
+ Double_t itsChi2[3] = {track->Pt(), static_cast<Double_t>(fCentralityF), itschi2percluster};
+ fQACollection->Fill("fChi2perITScluster", itsChi2);
+ }
+
+ // Fill Histogram for Hadronic Background
+ if(HasMCData()){
+ if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11))
+ fVarManager->FillContainer(fContainer, "hadronicBackground", UInt_t(0), kFALSE);
+ else if(mctrack){
+ // Fill Ke3 contributions
+ Int_t glabel=TMath::Abs(mctrack->GetMother());
+ if((mctrackmother = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(glabel)))){
+ if(TMath::Abs(mctrackmother->Particle()->GetPdgCode())==321)
+ fQACollection->Fill("Ke3Kecorr",mctrack->Pt(),mctrackmother->Pt());
+ else if(TMath::Abs(mctrackmother->Particle()->GetPdgCode())==130)
+ fQACollection->Fill("Ke3K0Lecorr",mctrack->Pt(),mctrackmother->Pt());
+ }
+ }
+ }
+
+ // Fill Containers
+ if(signal) {
+ // Apply weight for background contamination
+ if(fBackGroundFactorApply) {
+ if(IsHeavyIon() && fCentralityF >= 0) fWeightBackGround = fkBackGroundFactorArray[fCentralityF >= 0 ? fCentralityF : 0]->Eval(TMath::Abs(track->P()));
+ else fWeightBackGround = fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case
+
+ if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
+ else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
+ // weightBackGround as special weight
+ fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, fWeightBackGround);
+ }
+ fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterPID"));
+ }
+
+ Bool_t bTagged=kFALSE;
+ if(GetPlugin(kSecVtx)) {
+ AliDebug(2, "Running Secondary Vertex Analysis");
+ if(fSecVtx->Process(track) && signal) {
+ fVarManager->FillContainer(fContainer, "recTrackContSecvtxReco", AliHFEcuts::kStepHFEcutsSecvtx, kFALSE);
+ fVarManager->FillContainer(fContainer, "recTrackContSecvtxMC", AliHFEcuts::kStepHFEcutsSecvtx, kTRUE);
+ bTagged=kTRUE;
+ }
+ }
+
+ // Electron background analysis
+ if (GetPlugin(kIsElecBackGround)) {
+
+ AliDebug(2, "Running BackGround Analysis");
+
+ for(Int_t jtrack = 0; jtrack < fESD->GetNumberOfTracks(); jtrack++){
+ htrack = fESD->GetTrack(jtrack);
+ if ( itrack == jtrack ) continue;
+ fElecBackGround->PairAnalysis(track, htrack);
+ }
+ } // end of electron background analysis
+
+ if (GetPlugin(kDEstep)) {
+ Double_t weightElecBgV0[kBgLevels] = {0.,0.,0.,};
+ Int_t elecSource = 0;
+ Double_t hfeimpactR=0., hfeimpactnsigmaR=0.;
+ fExtraCuts->GetHFEImpactParameters(track, hfeimpactR, hfeimpactnsigmaR);
+ if(HasMCData())
+ {
+ if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)){
+ fQACollection->Fill("hadronsBeforeIPcut",track->Pt());
+ }
+ if(fMCQA && signal) {
+
+ fMCQA->SetContainerStep(0);
+ for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
+ weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE
+ if(!fisNonHFEsystematics || IsPbPb())break;
+ }
+
+ if(fisNonHFEsystematics){
+ //Fill additional containers for electron source distinction
+ elecSource = fMCQA->GetElecSource(mctrack->Particle());
+ const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};
+ const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};
+ Int_t iName = 0;
+ for(Int_t iSource = AliHFEmcQA::kPi0; iSource <= AliHFEmcQA::kGammaRho0; iSource++){
+ if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;
+ if(elecSource == iSource){
+ for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
+ if(weightElecBgV0[iLevel]>0) fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 0, kFALSE, weightElecBgV0[iLevel]);
+ else if(weightElecBgV0[iLevel]<0) fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 0, kFALSE, -1*weightElecBgV0[iLevel]);
+ if(IsPbPb())break;
+ }
+ break;
+ }
+ iName++;
+ if(iName == kElecBgSpecies)iName = 0;
+ }
+ }
+ //else{
+ if(weightElecBgV0[0]>0) {
+ fVarManager->FillContainer(fContainer, "conversionElecs", 0, kFALSE, weightElecBgV0[0]);
+ fVarManager->FillContainer(fContainer, "conversionElecs", 5, kTRUE, weightElecBgV0[0]);
+ }
+ else if(weightElecBgV0[0]<0) {
+ fVarManager->FillContainer(fContainer, "mesonElecs", 0, kFALSE, -1*weightElecBgV0[0]);
+ fVarManager->FillContainer(fContainer, "mesonElecs", 5, kTRUE, -1*weightElecBgV0[0]);
+ }
+ //}
+ if(bTagged){ // bg estimation for the secondary vertex tagged signals
+ if(weightElecBgV0[0]>0) fVarManager->FillContainer(fContainer, "conversionElecs", 2, kFALSE, weightElecBgV0[0]);
+ else if(weightElecBgV0[0]<0) fVarManager->FillContainer(fContainer, "mesonElecs", 2, kFALSE, -1*weightElecBgV0[0]);
+ }
+ }
+ } // end of MC
+
+ dataDca[0]=-1; //for data, don't know the origin
+ dataDca[1]=track->Pt();
+ dataDca[2]=hfeimpactR;
+ dataDca[3]=fCentralityF;
+ dataDca[4] = v0pid;
+ dataDca[5] = double(track->Charge());
+ if (!HasMCData()) fQACollection->Fill("Dca", dataDca);
+
+ // Fill Containers for impact parameter analysis
+ if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsDca + AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack,track)) continue;
+ if(signal) {
+ // Apply weight for background contamination after ip cut
+ if(fBackGroundFactorApply) {
+ fWeightBackGround = fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case
+ if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
+ else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
+ // weightBackGround as special weight
+ fVarManager->FillContainer(fContainer, "hadronicBackground", 2, kFALSE, fWeightBackGround);
+ }
+ }
+
+ if(HasMCData()){
+ if(fMCQA && signal) {
+ fMCQA->SetContainerStep(1);
+ for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
+ weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE
+ if(!fisNonHFEsystematics || IsPbPb())break;
+ }
+ if(fisNonHFEsystematics){
+ //Fill additional containers for electron source distinction
+ elecSource = fMCQA->GetElecSource(mctrack->Particle());
+ const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};
+ const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};
+ Int_t iName = 0;
+ for(Int_t iSource = AliHFEmcQA::kPi0; iSource <= AliHFEmcQA::kGammaRho0; iSource++){
+ if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;
+ if(elecSource == iSource){
+ for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
+ if(weightElecBgV0[iLevel]>0) fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 1, kFALSE, weightElecBgV0[iLevel]);
+ else if(weightElecBgV0[iLevel]<0) fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 1, kFALSE, -1*weightElecBgV0[iLevel]);
+ if(IsPbPb())break;
+ }
+ break;
+ }
+ iName++;
+ if(iName == kElecBgSpecies)iName = 0;
+ }
+ }
+ // else{
+ if(weightElecBgV0[0]>0) {
+ fVarManager->FillContainer(fContainer, "conversionElecs", 1, kFALSE, weightElecBgV0[0]);
+ fVarManager->FillContainer(fContainer, "conversionElecs", 6, kTRUE, weightElecBgV0[0]);
+ }
+ else if(weightElecBgV0[0]<0) {
+ fVarManager->FillContainer(fContainer, "mesonElecs", 1, kFALSE, -1*weightElecBgV0[0]);
+ fVarManager->FillContainer(fContainer, "mesonElecs", 6, kTRUE, -1*weightElecBgV0[0]);
+ }
+ //}
+ }
+ }
+ if(signal) {
+ fVarManager->FillContainer(fContainer, "recTrackContDEReco", AliHFEcuts::kStepHFEcutsDca, kFALSE);
+ fVarManager->FillContainer(fContainer, "recTrackContDEMC", AliHFEcuts::kStepHFEcutsDca, kTRUE);
+ fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterDE"));
+ }
+ if(HasMCData()){
+ if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)){
+ fQACollection->Fill("hadronsAfterIPcut",track->Pt());
+ }
+ }
+ }
+
+ }
+
+ // Background subtraction-------------------------------------------------------------------
+ if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->CountPoolAssociated(fInputEvent, fCentralityF);
+ //------------------------------------------------------------------------------------------
+
+ fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);
+}
+
+//____________________________________________________________
+void AliAnalysisTaskHFE::ProcessAOD(){
+ //
+ // Run Analysis in AOD Mode
+ // Function is still in development
+ //
+ //printf("Process AOD\n");
+ AliDebug(3, "Processing AOD Event");
+ Double_t eventContainer[4];
+ eventContainer[0] = 0.0;
+ if(HasMCData()) eventContainer[0] = fVz;
+ else {
+ if(fInputEvent->GetPrimaryVertex()) eventContainer[0] = fInputEvent->GetPrimaryVertex()->GetZ();
+ }
+ eventContainer[1] = 1.; // No Information available in AOD analysis, assume all events have V0AND
+ eventContainer[2] = fCentralityF;
+ eventContainer[3] = fContributors;
+
+ //printf("value event container %f, %f, %f, %f\n",eventContainer[0],eventContainer[1],eventContainer[2],eventContainer[3]);
+
+ AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);
+ if(!fAOD){
+ AliError("AOD Event required for AOD Analysis");
+ return;
+ }
+
+ //printf("Will fill\n");
+ //
+ fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoCut);
+ //printf("Fill\n");
+ //
+ if(fIdentifiedAsPileUp) return;
+ fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoPileUp);
+
+ //
+ if(fIdentifiedAsOutInz) return;
+ fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepZRange);
+
+ //
+ if(!fPassTheEventCut) return;
+ fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepReconstructed);
+ //printf("pass\n");
+
+ fContainer->NewEvent();
+
+ fCFM->SetRecEventInfo(fAOD);
+
+ if(!fExtraCuts){
+ fExtraCuts = new AliHFEextraCuts("hfeExtraCuts","HFE Extra Cuts");
+ }
+ fExtraCuts->SetRecEventInfo(fAOD);
+
+ // Get Number of contributors to the primary vertex for multiplicity-dependent correction
+ Int_t ncontribVtx = 0;
+ AliAODVertex *priVtx = fAOD->GetPrimaryVertex();
+ if(priVtx){
+ ncontribVtx = priVtx->GetNContributors();
+ }
+
+ // Look for kink mother
+ Int_t numberofvertices = fAOD->GetNumberOfVertices();
+ Double_t listofmotherkink[numberofvertices];
+ Int_t numberofmotherkink = 0;
+ for(Int_t ivertex=0; ivertex < numberofvertices; ivertex++) {
+ AliAODVertex *aodvertex = fAOD->GetVertex(ivertex);
+ if(!aodvertex) continue;
+ if(aodvertex->GetType()==AliAODVertex::kKink) {
+ AliAODTrack *mother = (AliAODTrack *) aodvertex->GetParent();
+ if(!mother) continue;
+ Int_t idmother = mother->GetID();
+ listofmotherkink[numberofmotherkink] = idmother;
+ //printf("ID %d\n",idmother);
+ numberofmotherkink++;
+ }
+ }
+ //printf("Number of kink mother in the events %d\n",numberofmotherkink);
+
+ // Background subtraction-------------------------------------------------------------------
+ if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent, fCentralityF);
+ //------------------------------------------------------------------------------------------
+
+ // Loop over tracks
+ AliAODTrack *track = NULL;
+ AliAODMCParticle *mctrack = NULL;
+ Double_t dataDca[6]; // [source, pT, dca, centrality]
+ Int_t nElectronCandidates = 0;
+ Bool_t signal;
+
+ //printf("Number of track %d\n",(Int_t) fAOD->GetNumberOfTracks());
+ for(Int_t itrack = 0; itrack < fAOD->GetNumberOfTracks(); itrack++){
+ track = fAOD->GetTrack(itrack); mctrack = NULL;
+ if(!track) continue;
+
+ signal = kTRUE;
+ if(HasMCData()){
+
+ Int_t label = TMath::Abs(track->GetLabel());
+ if(label && label < fAODArrayMCInfo->GetEntriesFast())
+ mctrack = dynamic_cast<AliAODMCParticle *>(fAODArrayMCInfo->At(label));
+ if(fFillSignalOnly && !fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, mctrack)) signal = kFALSE;
+ }
+
+ fVarManager->NewTrack(track, mctrack, fCentralityF, -1, signal);
+
+ if(fFillNoCuts) {
+ if(signal || !fFillSignalOnly){
+ fVarManager->FillContainer(fContainer, "recTrackContReco", AliHFEcuts::kStepRecNoCut, kFALSE);
+ fVarManager->FillContainer(fContainer, "recTrackContMC", AliHFEcuts::kStepRecNoCut, kTRUE);
+ }
+ }
+
+ if(fApplyCutAOD) {
+ //printf("Apply cuts\n");
+ // RecKine: ITSTPC cuts
+ if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;
+
+ // Reject kink mother
+ if(fRejectKinkMother) {
+ Bool_t kinkmotherpass = kTRUE;
+ for(Int_t kinkmother = 0; kinkmother < numberofmotherkink; kinkmother++) {
+ if(track->GetID() == listofmotherkink[kinkmother]) {
+ kinkmotherpass = kFALSE;
+ continue;
+ }
+ }
+ if(!kinkmotherpass) continue;
+ }
+
+ // RecPrim
+ if(!ProcessCutStep(AliHFEcuts::kStepRecPrim, track)) continue;
+
+ // HFEcuts: ITS layers cuts
+ if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsITS, track)) continue;
+
+ // HFE cuts: TOF PID and mismatch flag
+ if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTOF, track)) continue;
+
+ // HFE cuts: TPC PID cleanup
+ if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTPC, track)) continue;
+
+ // HFEcuts: Nb of tracklets TRD0
+ if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTRD, track)) continue;
+ }
+
+ // Fill correlation maps before PID
+ if(signal && fContainer->GetCorrelationMatrix("correlationstepbeforePID")) {
+ //printf("Fill correlation maps before PID\n");
+ fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepbeforePID"));
+ }
+
+ if(HasMCData()){
+ Double_t hfeimpactR4all=0., hfeimpactnsigmaR4all=0.;
+ Int_t sourceDca =-1;
+ if(mctrack && (TMath::Abs(mctrack->GetPdgCode()) == 211)){
+ if(track->Pt()>4.){
+ fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);
+ dataDca[0]=0; //pion
+ dataDca[1]=track->Pt();
+ dataDca[2]=hfeimpactR4all;
+ dataDca[3]=fCentralityF;
+ dataDca[4] = -1; // not store V0 for the moment
+ dataDca[5] = double(track->Charge());
+ fQACollection->Fill("Dca", dataDca);
+ }
+ }
+ else if(mctrack && (TMath::Abs(mctrack->GetPdgCode()) == 11)){ // to increas statistics for Martin
+ if(signal){
+ fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);
+ if(fSignalCuts->IsCharmElectron(track)){
+ sourceDca=1;
+ }
+ else if(fSignalCuts->IsBeautyElectron(track)){
+ sourceDca=2;
+ }
+ else if(fSignalCuts->IsGammaElectron(track)){
+ sourceDca=3;
+ }
+ else if(fSignalCuts->IsNonHFElectron(track)){
+ sourceDca=4;
+ }
+ else if(fSignalCuts->IsJpsiElectron(track)){
+ sourceDca=5;
+ }
+ else {
+ sourceDca=6;
+ }
+ dataDca[0]=sourceDca;
+ dataDca[1]=track->Pt();
+ dataDca[2]=hfeimpactR4all;
+ dataDca[3]=fCentralityF;
+ dataDca[4] = -1; // not store V0 for the moment
+ dataDca[5] = double(track->Charge());
+ if(signal) fQACollection->Fill("Dca", dataDca);
+ }
+ }
+ }
+
+ //printf("Will process to PID\n");
+
+ // track accepted, do PID
+ AliHFEpidObject hfetrack;
+ hfetrack.SetAnalysisType(AliHFEpidObject::kAODanalysis);
+ hfetrack.SetRecTrack(track);
+ if(HasMCData()) hfetrack.SetMCTrack(mctrack);
+ hfetrack.SetCentrality(fCentralityF);
+ hfetrack.SetMulitplicity(ncontribVtx); // for correction
+ if(IsHeavyIon()) hfetrack.SetPbPb();
+ else hfetrack.SetPP();
+ fPID->SetVarManager(fVarManager);
+ if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue;
+ // we will do PID here as soon as possible
+
+ // Background subtraction----------------------------------------------------------------------------------------------
+ if (GetPlugin(kNonPhotonicElectron)) {
+ Int_t indexmother = -1;
+ Int_t mcsource = -1;
+ if(HasMCData() && mctrack) mcsource = fBackgroundSubtraction->FindMother(mctrack->GetLabel(),indexmother);
+ fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, 1, fCentralityF, -1,mcsource, indexmother);
+ }
+ //---------------------------------------------------------------------------------------------------------------------
+
+ // end AOD QA
+ fQACollection->Fill("Filterend", -1);
+ for(Int_t k=0; k<20; k++) {
+ Int_t u = 1<<k;
+ if((track->TestFilterBit(u))) {
+ fQACollection->Fill("Filterend", k);
+ }
+ }
+
+ // Apply weight for background contamination
+ //Double_t weightBackGround = 1.0;
+ if(signal) {
+ // Apply weight for background contamination
+ if(fBackGroundFactorApply) {
+ if(IsHeavyIon() && fCentralityF >= 0) fWeightBackGround = fkBackGroundFactorArray[fCentralityF >= 0 ? fCentralityF : 0]->Eval(TMath::Abs(track->P()));
+ else fWeightBackGround = fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case
+
+ if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
+ else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
+ // weightBackGround as special weight
+ fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, fWeightBackGround);
+ }
+ fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterPID"));
+ }
+
+ nElectronCandidates++;
+
+ if (GetPlugin(kDEstep)) {
+ if (!HasMCData()){
+ Double_t hfeimpactR=0., hfeimpactnsigmaR=0.;
+ fExtraCuts->GetHFEImpactParameters(track, hfeimpactR, hfeimpactnsigmaR);
+ dataDca[0]=-1; //for data, don't know the origin
+ dataDca[1]=track->Pt();
+ dataDca[2]=hfeimpactR;
+ dataDca[3]=fCentralityF;
+ dataDca[4] = -1; // not store V0 for the moment
+ dataDca[5] = double(track->Charge());
+ fQACollection->Fill("Dca", dataDca);
+ }
+
+ // Fill Containers for impact parameter analysis
+ if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsDca + AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack,track)) continue;
+ if(signal) {
+ // Apply weight for background contamination after ip cut
+ if(fBackGroundFactorApply) {
+ fWeightBackGround = fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case
+ if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
+ else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
+ // weightBackGround as special weight
+ fVarManager->FillContainer(fContainer, "hadronicBackground", 2, kFALSE, fWeightBackGround);
+ }
+ }
+ }
+ }
+
+ // Background subtraction-------------------------------------------------------------------
+ if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->CountPoolAssociated(fInputEvent, fCentralityF);
+ //------------------------------------------------------------------------------------------
+
+ fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);
+}
+
+//____________________________________________________________
+Bool_t AliAnalysisTaskHFE::ProcessMCtrack(AliVParticle *track){
+ //
+ // Filter the Monte Carlo Track
+ // Additionally Fill a THnSparse for Signal To Background Studies
+ // Works for AOD and MC analysis Type
+ //
+ fVarManager->NewTrack(track, NULL, fCentralityF, -1, kTRUE);
+
+
+ Double_t vertex[3] = {0.,0.,0.}; // Production vertex cut to mask gammas which are NOT supposed to have hits in the first ITS layer(s)
+ if(IsESDanalysis()){
+ AliMCParticle *mctrack = dynamic_cast<AliMCParticle *>(track);
+ if(mctrack){
+ vertex[0] = mctrack->Particle()->Vx();
+ vertex[1] = mctrack->Particle()->Vy();
+ }
+ } else {
+ AliAODMCParticle *aodmctrack = dynamic_cast<AliAODMCParticle *>(track);
+ if(aodmctrack) aodmctrack->XvYvZv(vertex);
+ }
+
+ //printf("MC Generated\n");
+ if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, track)) return kFALSE;
+ //printf("MC Generated pass\n");
+ fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGenerated, kFALSE);
+
+ // Step GeneratedZOutNoPileUp
+ if((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0)) return kFALSE;
+ fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGeneratedZOutNoPileUpCentralityFine, kFALSE);
+ //printf("In ProcessMCtrack %f\n",fCentralityF);
+
+ // Step Generated Event Cut
+ if(!fPassTheEventCut) return kFALSE;
+ fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGeneratedEventCut, kFALSE);
+
+ if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCInAcceptance, track)) return kFALSE;
+ fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCInAcceptance, kFALSE);
+ return kTRUE;
+}
+
+//____________________________________________________________
+Bool_t AliAnalysisTaskHFE::PreSelectTrack(AliESDtrack *track) const {
+ //
+ // Preselect tracks
+ //
+
+
+ Bool_t survived = kTRUE;
+
+ if(fCutspreselect) {
+ //printf("test preselect\n");
+ if(!fCutspreselect->IsSelected(track)) survived=kFALSE;
+ }
+ //printf("survived %d\n",(Int_t)survived);
+
+ if(survived && fPIDpreselect){
+ // Apply PID
+ AliHFEpidObject hfetrack;
+ hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);
+ hfetrack.SetRecTrack(track);
+ if(!fPIDpreselect->IsSelected(&hfetrack)) {
+ //printf("Did not pass AliHFEcuts::kPID\n");
+ survived = kFALSE;
+ }
+ //else printf("Pass AliHFEcuts::kPID\n");
+ }
+
+ return survived;
+
+}
+//____________________________________________________________
+void AliAnalysisTaskHFE::MakeEventContainer(){
+ //
+ // Create the event container for the correction framework and link it
+ // 1st bin: Vertex z-position
+ // 2nd bin: V0AND decision (normalization to sigma_inel)
+ // 3rd bin: Centrality class (for pp defined as number of contributors in vertex.)
+ // 4th bin: Number of contributors > 0
+ //
+
+ const Int_t kNvar = 4; // number of variables on the grid:
+ Int_t nBins[kNvar] = {120, 2, 11, 2};
+ Double_t binMin[kNvar] = {-30. , 0., 0.0, 0.};
+ Double_t binMax[kNvar] = {30., 2., 11.0, 2.};
+
+ AliCFContainer *evCont = new AliCFContainer("eventContainer", "Container for events", AliHFEcuts::kNcutStepsEvent, kNvar, nBins);
+
+ Double_t *vertexBins = AliHFEtools::MakeLinearBinning(nBins[0], binMin[0], binMax[0]);
+ Double_t *v0andBins = AliHFEtools::MakeLinearBinning(nBins[1], binMin[1], binMax[1]);
+ Double_t *centralityBins = AliHFEtools::MakeLinearBinning(nBins[2], binMin[2], binMax[2]);
+ Double_t *contributorsBins = AliHFEtools::MakeLinearBinning(nBins[3], binMin[3], binMax[3]);
+ evCont->SetBinLimits(0, vertexBins);
+ evCont->SetBinLimits(1, v0andBins);
+ evCont->SetBinLimits(2, centralityBins);
+ evCont->SetBinLimits(3, contributorsBins);
+ delete[] vertexBins; delete[] v0andBins; delete[] centralityBins; delete[] contributorsBins;
+
+ fCFM->SetEventContainer(evCont);
+}
+
+//____________________________________________________________
+void AliAnalysisTaskHFE::MakeParticleContainer(){
+ //
+ // Create the particle container for the correction framework manager and
+ // link it
+ //
+ if(!fContainer) fContainer = new AliHFEcontainer("trackContainer");
+ fVarManager->DefineVariables(fContainer);
+
+ // Create Correction Framework containers
+ fContainer->CreateContainer("MCTrackCont", "Track Container filled with MC information", AliHFEcuts::kNcutStepsMCTrack);
+ fContainer->CreateContainer("recTrackContReco", "Track Container filled with MC information", AliHFEcuts::kNcutStepsRecTrack + fPID->GetNumberOfPIDdetectors());
+ fContainer->CreateContainer("recTrackContMC", "Track Container filled with MC information", AliHFEcuts::kNcutStepsRecTrack + fPID->GetNumberOfPIDdetectors());
+
+ fContainer->CreateContainer("hadronicBackground", "Container for Hadronic Background", 3);
+ fContainer->CreateContainer("recTrackContDEReco", "Container for displaced electron analysis with Reco information", 1);
+ fContainer->CreateContainer("recTrackContDEMC", "Container for displaced electron analysis with MC information", 1);
+ fContainer->CreateContainer("recTrackContSecvtxReco", "Container for secondary vertexing analysis with Reco information", 1);
+ fContainer->CreateContainer("recTrackContSecvtxMC", "Container for secondary vertexing analysis with MC information", 1);
+
+ if(HasMCData()){
+ fContainer->CreateContainer("conversionElecs", "Container for weighted conversion electrons",7);
+ fContainer->CreateContainer("mesonElecs", "Container for weighted electrons from meson decays",7);
+ fContainer->Sumw2("conversionElecs");
+ fContainer->Sumw2("mesonElecs");
+
+ if(fisNonHFEsystematics){
+ const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};
+ const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};
+ for(Int_t iSource = 0; iSource < kElecBgSpecies; iSource++){
+ for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
+ fContainer->CreateContainer(Form("conversionElecs%s%s",sourceName[iSource],levelName[iLevel]), Form("Container for weighted conversion electrons from %s grandm., %s level",sourceName[iSource],levelName[iLevel]),5);
+ fContainer->CreateContainer(Form("mesonElecs%s%s",sourceName[iSource],levelName[iLevel]), Form("Container for weighted electrons from %s decays, %s level",sourceName[iSource],levelName[iLevel]),5);
+ fContainer->Sumw2(Form("conversionElecs%s%s",sourceName[iSource],levelName[iLevel]));
+ fContainer->Sumw2(Form("mesonElecs%s%s",sourceName[iSource],levelName[iLevel]));
+ if(IsPbPb())break;
+ }
+ }
+ }
+ //fContainer->CreateContainer("charmElecs", "Container for weighted charm electrons",2);
+ }
+
+ fContainer->CreateCorrelationMatrix("correlationstepafterPID","THnSparse with correlations");
+ fContainer->CreateCorrelationMatrix("correlationstepafterDE","THnSparse with correlations");
+ if(!fVarManager->IsVariableDefined("centrality")) {
+ //printf("Create the two other correlation maps\n");
+ fContainer->CreateCorrelationMatrix("correlationstepbeforePID","THnSparse with correlations");
+ fContainer->CreateCorrelationMatrix("correlationstepafterTOF","THnSparse with correlations");
+ }
+
+ // Define the step names
+ for(UInt_t istep = 0; istep < AliHFEcuts::kNcutStepsMCTrack; istep++){
+ fContainer->SetStepTitle("MCTrackCont", AliHFEcuts::MCCutName(istep), istep);
+ }
+ for(UInt_t istep = 0; istep < AliHFEcuts::kNcutStepsRecTrack; istep++){
+ fContainer->SetStepTitle("recTrackContReco", AliHFEcuts::RecoCutName(istep), istep);
+ fContainer->SetStepTitle("recTrackContMC", AliHFEcuts::RecoCutName(istep), istep);
+ }
+ for(UInt_t ipid = 0; ipid < fPID->GetNumberOfPIDdetectors(); ipid++){
+ fContainer->SetStepTitle("recTrackContReco", fPID->SortedDetectorName(ipid), AliHFEcuts::kNcutStepsRecTrack + ipid);
+ fContainer->SetStepTitle("recTrackContMC", fPID->SortedDetectorName(ipid), AliHFEcuts::kNcutStepsRecTrack + ipid);
+ }
+}
+//____________________________________________________________
+void AliAnalysisTaskHFE::InitContaminationQA(){
+ //
+ // Add QA for Impact Parameter cut
+ //
+
+ TObjArray *array = fVarManager->GetVariables();
+ Int_t nvars = array->GetEntriesFast();
+ for(Int_t v = 0; v < nvars; v++) {
+ AliHFEvarManager::AliHFEvariable *variable = (AliHFEvarManager::AliHFEvariable *) array->At(v);
+ if(!variable) continue;
+ TString name(((AliHFEvarManager::AliHFEvariable *)variable)->GetName());
+ if(!name.CompareTo("pt")) {
+ const Int_t nBinPt = variable->GetNumberOfBins();
+ const Double_t *kPtRange = variable->GetBinning();
+
+ fQACollection->CreateTH1Farray("hadronsBeforeIPcut", "Hadrons before IP cut", nBinPt, kPtRange);
+ fQACollection->CreateTH1Farray("hadronsAfterIPcut", "Hadrons after IP cut", nBinPt, kPtRange);
+
+ fQACollection->CreateTH2Farray("Ke3Kecorr", "Ke3 decay e and K correlation; Ke3K p_{t}; Ke3e p_{t}; ", nBinPt, kPtRange, 20,0.,20.);
+ fQACollection->CreateTH2Farray("Ke3K0Lecorr", "Ke3 decay e and K0L correlation; Ke3K0L p_{t}; Ke3e p_{t}; ", nBinPt, kPtRange, 20,0.,20.);
+ fQACollection->CreateTH1Farray("Kptspectra", "Charged Kaons: MC p_{t} ", nBinPt, kPtRange);
+ fQACollection->CreateTH1Farray("K0Lptspectra", "K0L: MC p_{t} ", nBinPt, kPtRange);
+
+ const Double_t kDCAbound[2] = {-0.2, 0.2};
+
+ const Int_t nDimDca=6;
+ const Int_t nBinDca[nDimDca] = { 8, nBinPt, 800, 12, 6, 2};
+ Double_t minimaDca[nDimDca] = { -1., 0., kDCAbound[0], -1., -1, -1.1};
+ Double_t maximaDca[nDimDca] = { 7., 20., kDCAbound[1], 11., 5, 1.1};
+
+ Double_t *sourceBins = AliHFEtools::MakeLinearBinning(nBinDca[0], minimaDca[0], maximaDca[0]);
+ Double_t *dcaBins = AliHFEtools::MakeLinearBinning(nBinDca[2], minimaDca[2], maximaDca[2]);
+ Double_t *centralityBins = AliHFEtools::MakeLinearBinning(nBinDca[3], minimaDca[3], maximaDca[3]);
+ Double_t *v0PIDBins = AliHFEtools::MakeLinearBinning(nBinDca[4], minimaDca[4], maximaDca[4]);
+ Double_t *chargeBins = AliHFEtools::MakeLinearBinning(nBinDca[5], minimaDca[5], maximaDca[5]);
+
+ fQACollection->CreateTHnSparseNoLimits("Dca", "Dca; source (0-all, 1-charm,etc); pT [GeV/c]; dca; centrality bin; v0pid; charge", nDimDca, nBinDca);
+ ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(0, sourceBins);
+ ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(1, kPtRange);
+ ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(2, dcaBins);
+ ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(3, centralityBins);
+ ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(4, v0PIDBins);
+ ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(5, chargeBins);
+
+ break;
+ }
+ }
+
+}
+
+//____________________________________________________________
+void AliAnalysisTaskHFE::InitHistoITScluster(){
+ //
+ // Initialize a temporary histogram to monitor the chi2/ITS cluster
+ if(IsPbPb()) {
+ const Int_t kNDim = 7;
+ const Int_t kNBins[kNDim] = {88, 20,90,11, 160, 2, 1000};
+ const Double_t kMin[kNDim] = {0.1, -1,0, 0.,0., 0, 0.};
+ const Double_t kMax[kNDim] = {20., 1, 2.*TMath::Pi(), 11.,160, 2, 100.};
+ fQACollection->CreateTHnSparse("fChi2perITScluster", "chi2/ITS cluster; p_{T} (GeV/c);eta;phi; centrality class;nclus;sharebit; #chi^{2}/ITS cluster", kNDim, kNBins, kMin, kMax);
+ fQACollection->BinLogAxis("fChi2perITScluster", 0);
+ }
+ else
+ {
+ const Int_t kNDim = 3;
+ const Int_t kNBins[kNDim] = {44, 11, 1000};
+ const Double_t kMin[kNDim] = {0.1, 0., 0.};
+ const Double_t kMax[kNDim] = {20., 11., 100.};
+ fQACollection->CreateTHnSparse("fChi2perITScluster", "chi2/ITS cluster; p_{T} (GeV/c); centrality class; #chi^{2}/ITS cluster", kNDim, kNBins, kMin, kMax);
+ fQACollection->BinLogAxis("fChi2perITScluster", 0);
+ }
+}
+
+//____________________________________________________________
+void AliAnalysisTaskHFE::SelectSpecialTrigger(const Char_t *trgclust, Int_t runMin, Int_t runMax){
+ //
+ // Select only events triggered by a special trigeer cluster
+ //
+ if(!fSpecialTrigger) fSpecialTrigger = new AliOADBContainer("SpecialTrigger");
+ fSpecialTrigger->AppendObject(new TObjString(trgclust), runMin, runMax);
+}
+
+//____________________________________________________________
+const Char_t * AliAnalysisTaskHFE::GetSpecialTrigger(Int_t run){
+ //
+ // Derive selected trigger string for given run
+ //
+ if(!fSpecialTrigger) return NULL;
+ TObjString *trg = dynamic_cast<TObjString *>(fSpecialTrigger->GetObject(run));
+ if(!trg) return NULL;
+ return trg->String().Data();
+}
+
+//____________________________________________________________
+void AliAnalysisTaskHFE::PrintStatus() const {
+ //
+ // Print Analysis status
+ //
+ printf("\n\tAnalysis Settings\n\t========================================\n\n");
+ printf("\tSecondary Vertex finding: %s\n", GetPlugin(kSecVtx) ? "YES" : "NO");
+ printf("\tPrimary Vertex resolution: %s\n", GetPlugin(kPriVtx) ? "YES" : "NO");
+ printf("\tDisplaced electron analysis step: %s\n", GetPlugin(kDEstep) ? "YES" : "NO");
+ printf("\tTagged Track Analysis: %s\n", GetPlugin(kTaggedTrackAnalysis) ? "YES" : "NO");
+ printf("\n");
+ printf("\tParticle Identification Detectors:\n");
+ fPID->PrintStatus();
+ printf("\n");
+ printf("\tQA: \n");
+ printf("\t\tPID: %s\n", IsQAOn(kPIDqa) ? "YES" : "NO");
+ printf("\t\tCUTS: %s\n", (fCuts != NULL && fCuts->IsQAOn()) ? "YES" : "NO");
+ printf("\t\tMC: %s\n", IsQAOn(kMCqa) ? "YES" : "NO");
+ printf("\n");
+}
+
+//____________________________________________________________
+Bool_t AliAnalysisTaskHFE::FillProductionVertex(const AliVParticle * const track) const{
+ //
+ // Find the production vertex of the associated MC track
+ //
+ if(!fMCEvent) return kFALSE;
+ const AliVParticle *mctrack = NULL;
+ TString objectType = track->IsA()->GetName();
+ if(objectType.CompareTo("AliESDtrack") == 0 || objectType.CompareTo("AliAODTrack") == 0){
+ // Reconstructed track
+ mctrack = fMCEvent->GetTrack(TMath::Abs(track->GetLabel()));
+ } else {
+ // MCParticle
+ mctrack = track;
+ }
+
+ if(!mctrack) return kFALSE;
+
+ Double_t xv = 0.0;
+ Double_t yv = 0.0;
+
+ if(TString(mctrack->IsA()->GetName()).CompareTo("AliMCParticle") == 0){
+ // case MCParticle
+ const AliMCParticle *mcpart = dynamic_cast<const AliMCParticle *>(mctrack);
+ if(mcpart){
+ xv = mcpart->Xv();
+ yv = mcpart->Yv();
+ }
+ } else {
+ // case AODMCParticle
+ const AliAODMCParticle *mcpart = dynamic_cast<const AliAODMCParticle *>(mctrack);
+ if(mcpart){
+ xv = mcpart->Xv();
+ yv = mcpart->Yv();
+ }
+ }
+
+ //printf("xv %f, yv %f\n",xv,yv);
+ fQACollection->Fill("radius", TMath::Abs(xv),TMath::Abs(yv));
+
+ return kTRUE;
+
+}
+//__________________________________________
+void AliAnalysisTaskHFE::SwitchOnPlugin(Int_t plug){
+ //
+ // Switch on Plugin
+ // Available:
+ // - Primary vertex studies
+ // - Secondary vertex Studies
+ // - Post Processing
+ //
+ switch(plug){
+ case kPriVtx: SETBIT(fPlugins, plug); break;
+ case kSecVtx: SETBIT(fPlugins, plug); break;
+ case kIsElecBackGround: SETBIT(fPlugins, plug); break;
+ case kPostProcess: SETBIT(fPlugins, plug); break;
+ case kDEstep: SETBIT(fPlugins, plug); break;
+ case kTaggedTrackAnalysis: SETBIT(fPlugins, plug); break;
+ case kNonPhotonicElectron: SETBIT(fPlugins, plug); break;
+ default: AliError("Unknown Plugin");
+ };
+}
+//__________________________________________
+Bool_t AliAnalysisTaskHFE::ProcessCutStep(Int_t cutStep, AliVParticle *track){
+ //
+ // Check single track cuts for a given cut step
+ // Fill the particle container
+ //
+ const Int_t kMCOffset = AliHFEcuts::kNcutStepsMCTrack;
+ if(!fCFM->CheckParticleCuts(cutStep + kMCOffset, track)) return kFALSE;
+ if(fVarManager->IsSignalTrack()) {
+ fVarManager->FillContainer(fContainer, "recTrackContReco", cutStep, kFALSE);
+ fVarManager->FillContainer(fContainer, "recTrackContMC", cutStep, kTRUE);
+ }
+ return kTRUE;
+}
+//___________________________________________________
+Bool_t AliAnalysisTaskHFE::ReadCentrality() {
+ //
+ // Recover the centrality of the event from ESD or AOD
+ //
+
+ Float_t fCentralityLimitstemp[12];
+ Float_t fCentralityLimitsdefault[12]= {0.,5.,10., 20., 30., 40., 50., 60.,70.,80., 90., 100.};
+ if(!fPbPbUserCentralityBinning) memcpy(fCentralityLimitstemp,fCentralityLimitsdefault,sizeof(fCentralityLimitsdefault));
+ else memcpy(fCentralityLimitstemp,fCentralityLimits,sizeof(fCentralityLimitsdefault));
+
+
+ Int_t bin = -1;
+ if(IsHeavyIon()) {
+ // Centrality
+ AliCentrality *centrality = fInputEvent->GetCentrality();
+ fCentralityPercent = centrality->GetCentralityPercentile(fCentralityEstimator.Data());
+ //printf("centrality %f\n",fCentralityPercent);
+
+ for(Int_t ibin = 0; ibin < 11; ibin++){
+ if(fCentralityPercent >= fCentralityLimitstemp[ibin] && fCentralityPercent < fCentralityLimitstemp[ibin+1]){
+ bin = ibin;
+ //printf("test bin %f, low %f, high %f, %d\n",fCentralityPercent,fCentralityLimitstemp[ibin],fCentralityLimitstemp[ibin+1],ibin);
+ break;
+ }
+ }
+
+ if(bin == -1) bin = 11; // Overflow
+ } else {
+ // PP: Tracklet multiplicity, use common definition
+ Int_t itsMultiplicity = GetITSMultiplicity(fInputEvent);
+ Int_t multiplicityLimits[8] = {0, 1, 9, 17, 25, 36, 60, 500};
+ for(Int_t ibin = 0; ibin < 7; ibin++){
+ if(itsMultiplicity >= multiplicityLimits[ibin] && itsMultiplicity < multiplicityLimits[ibin + 1]){
+ bin = ibin;
+ break;
+ }
+ }
+ if(bin == -1) bin = 7; // Overflow
+ }
+ fCentralityF = bin;
+ AliDebug(2, Form("Centrality class %d\n", fCentralityF));
+
+
+ // contributors, to be outsourced
+ const AliVVertex *vtx;
+ if(IsAODanalysis()){
+ AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);
+ if(!fAOD){
+ AliError("AOD Event required for AOD Analysis");
+ return kFALSE;
+ }
+ vtx = fAOD->GetPrimaryVertex();
+ } else {
+ AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);
+ if(!fESD){
+ AliError("ESD Event required for ESD Analysis");
+ return kFALSE;
+ }
+ vtx = fESD->GetPrimaryVertex() ;
+ }
+ if(!vtx){
+ fContributors = 0.5;
+ return kFALSE;
+ }
+ else {
+ Int_t contributorstemp = vtx->GetNContributors();
+ if( contributorstemp <= 0) {
+ fContributors = 0.5;
+ //printf("Number of contributors %d and vz %f\n",contributorstemp,vtx->GetZ());
+ }
+ else fContributors = 1.5;
+ //printf("Number of contributors %d\n",contributorstemp);
+ }
+ return kTRUE;
+}
+
+//___________________________________________________
+Int_t AliAnalysisTaskHFE::GetITSMultiplicity(AliVEvent *ev){
+ //
+ // Definition of the Multiplicity according to the JPSI group (F. Kramer)
+ //
+ Int_t nTracklets = 0;
+ Int_t nAcc = 0;
+ Double_t etaRange = 1.6;
+
+ if (ev->IsA() == AliAODEvent::Class()) {
+ AliAODTracklets *tracklets = ((AliAODEvent*)ev)->GetTracklets();
+ nTracklets = tracklets->GetNumberOfTracklets();
+ for (Int_t nn = 0; nn < nTracklets; nn++) {
+ Double_t theta = tracklets->GetTheta(nn);
+ Double_t eta = -TMath::Log(TMath::Tan(theta/2.0));
+ if (TMath::Abs(eta) < etaRange) nAcc++;
+ }
+ } else if (ev->IsA() == AliESDEvent::Class()) {
+ nTracklets = ((AliESDEvent*)ev)->GetMultiplicity()->GetNumberOfTracklets();
+ for (Int_t nn = 0; nn < nTracklets; nn++) {
+ Double_t eta = ((AliESDEvent*)ev)->GetMultiplicity()->GetEta(nn);
+ if (TMath::Abs(eta) < etaRange) nAcc++;
+ }
+ } else return -1;
+
+ return nAcc;
+}
+
+//___________________________________________________
+void AliAnalysisTaskHFE::RejectionPileUpVertexRangeEventCut() {
+ //
+ // Recover the centrality of the event from ESD or AOD
+ //
+ if(IsAODanalysis()){
+
+ AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);
+ if(!fAOD){
+ AliError("AOD Event required for AOD Analysis");
+ return;
+ }
+ // PileUp
+ fIdentifiedAsPileUp = kFALSE;
+ if(fRemovePileUp && fAOD->IsPileupFromSPD()) fIdentifiedAsPileUp = kTRUE;
+ // Z vertex
+ fIdentifiedAsOutInz = kFALSE;
+ //printf("Z vertex %f and out %f\n",fAOD->GetPrimaryVertex()->GetZ(),fCuts->GetVertexRange());
+ if(TMath::Abs(fAOD->GetPrimaryVertex()->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE;
+ // Event Cut
+ fPassTheEventCut = kTRUE;
+ if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fAOD)) fPassTheEventCut = kFALSE;
+
+
+ } else {
+
+ AliDebug(3, "Processing ESD Centrality");
+ AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);
+ if(!fESD){
+ AliError("ESD Event required for ESD Analysis");
+ return;
+ }
+ // PileUp
+ fIdentifiedAsPileUp = kFALSE;
+ if(fRemovePileUp && fESD->IsPileupFromSPD()) fIdentifiedAsPileUp = kTRUE;
+
+
+
+ // Z vertex
+ fIdentifiedAsOutInz = kFALSE;
+ Bool_t findvertex = kTRUE;
+ const AliESDVertex* vtxESD = fESD->GetPrimaryVertex();
+ if((!vtxESD) || (vtxESD->GetNContributors() <= 0)) findvertex = kFALSE;
+ if(findvertex) {
+ if(TMath::Abs(vtxESD->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE;
+ }
+
+ //Event Cut
+ fPassTheEventCut = kTRUE;
+ if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fESD)) fPassTheEventCut = kFALSE;
+
+ }
+
+}
+
+//___________________________________________________
+Bool_t AliAnalysisTaskHFE::CheckTRDTrigger(AliESDEvent *ev) {
+//
+// Check TRD trigger; pPb settings
+//
+ Bool_t cint8=kFALSE;
+ Bool_t cint7=kFALSE;
+ Bool_t cint5=kFALSE;
+ Bool_t trdtrgevent=kFALSE;
+ fTRDTriggerAnalysis->CalcTriggers(ev);
+
+ // HSE no cleanup
+ if(fWhichTRDTrigger==1)
+ {
+ cint8= ev->IsTriggerClassFired("CINT8WUHSE-B-NOPF-CENT");
+ cint7= ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT");
+ cint5= (ev->IsTriggerClassFired("CINT5WU-B-NOPF-ALL")) &&
+ (ev->GetHeader()->GetL1TriggerInputs() & (1 << 10));
+ if((cint7==kFALSE)&&(cint8==kFALSE)&&(cint5==kFALSE)) return kFALSE;
+ else
+ {
+ DrawTRDTrigger(ev);
+ return kTRUE;
+ }
+ }
+
+ // HSE cleanup
+ if(fWhichTRDTrigger==2)
+ {
+ if(!fTRDTriggerAnalysis->IsFired(AliTRDTriggerAnalysis::kHSE))
+ {
+ return kFALSE;
+ }
+ else
+ {
+ DrawTRDTrigger(ev);
+ return kTRUE;
+ }
+ }
+
+ //HQU no cleanup
+ if(fWhichTRDTrigger==3)
+ {
+ cint8= ev->IsTriggerClassFired("CINT8WUHQU-B-NOPF-CENT");
+ cint7= ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT");
+ cint5= (ev->IsTriggerClassFired("CINT5WU-B-NOPF-ALL")) &&
+ (ev->GetHeader()->GetL1TriggerInputs() & (1 << 12));
+ if((cint7==kFALSE)&&(cint8==kFALSE)&&(cint5==kFALSE)) return kFALSE;
+ else
+ {
+ DrawTRDTrigger(ev);
+ return kTRUE;
+ }
+ }
+
+ // HQU cleanup
+ if(fWhichTRDTrigger==4)
+ {
+
+ if(!fTRDTriggerAnalysis->IsFired(AliTRDTriggerAnalysis::kHQU))
+ {
+ return kFALSE;
+ }
+ else
+ {
+ DrawTRDTrigger(ev);
+ return kTRUE;
+ }
+ }
+
+ return trdtrgevent;
+
+}
+
+void AliAnalysisTaskHFE::DrawTRDTrigger(AliESDEvent *ev) {
+
+ Int_t ntriggerbit=0;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ if(ev->IsTriggerClassFired("CINT7-B-NOPF-ALLNOTRD"))
+ {
+ ntriggerbit=2;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ }
+ if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))
+ {
+ ntriggerbit=3;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
+ ntriggerbit=18;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ }
+ if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")) {
+ ntriggerbit=19;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ }
+ }
+ if(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-CENT"))
+ {
+ ntriggerbit=4;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+
+ if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
+ ntriggerbit=13;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ }
+ if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")) {
+ ntriggerbit=14;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
+ ntriggerbit=17;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ }
+ }
+ }
+ if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT"))
+ {
+ ntriggerbit=5;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
+ ntriggerbit=11;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ }
+ if((!(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")))&&(!(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-CENT")))) {
+ ntriggerbit=21;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+
+ /*
+ Int_t nTrdTracks = ev->GetNumberOfTrdTracks();
+ for (Int_t iTrack = 0; iTrack < nTrdTracks; ++iTrack) {
+ AliESDTrdTrack* trdTrack = ev->GetTrdTrack(iTrack);
+ printf("GTU track %3i: pt = %5.1f, PID = %3i\n", iTrack, trdTrack->Pt(), trdTrack->GetPID());
+ }*/
+
+
+ }
+
+ }
+ if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT"))
+ {
+ ntriggerbit=6;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")) {
+ ntriggerbit=12;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ }
+ if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-FAST")){
+ ntriggerbit=15;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+
+ if((!(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")))&&(!(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-CENT")))) {
+ ntriggerbit=20;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ /*
+ Int_t nTrdTracks = ev->GetNumberOfTrdTracks();
+ for (Int_t iTrack = 0; iTrack < nTrdTracks; ++iTrack) {
+ AliESDTrdTrack* trdTrack = ev->GetTrdTrack(iTrack);
+ printf("HSE GTU track %3i: pt = %5.1f, PID = %3i\n", iTrack, trdTrack->Pt(), trdTrack->GetPID());
+ } */
+
+ }
+
+ }
+
+ }
+ if(ev->IsTriggerClassFired("CEMC7WUHEE-B-NOPF-CENT")) {
+ ntriggerbit=7;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ }
+ if(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-FAST")){
+ ntriggerbit=8;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ }
+ if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-FAST")){
+ ntriggerbit=9;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ }
+ if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-FAST")){
+ ntriggerbit=10;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
+ ntriggerbit=16;
+ fQACollection->Fill("nTriggerBit",ntriggerbit);
+ }
+ }
+ if(ntriggerbit==0) fQACollection->Fill("nTriggerBit",1);
+
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff