#include "AliHFEsignalCuts.h"
#include "AliHFEtaggedTrackAnalysis.h"
#include "AliHFEtools.h"
+#include "AliHFEV0taginfo.h"
#include "AliHFEvarManager.h"
#include "AliAnalysisTaskHFE.h"
#include "AliAODMCHeader.h"
, fPlugins(0)
, fCollisionSystem(3)
, fFillSignalOnly(kTRUE)
+ , fRejectMCFakeTracks(kFALSE)
, fFillNoCuts(kFALSE)
- , fApplyCutAOD(kTRUE)
, fBackGroundFactorApply(kFALSE)
, fRemovePileUp(kFALSE)
, fIdentifiedAsPileUp(kFALSE)
, fTriggerAnalysis(NULL)
, fPID(NULL)
, fPIDqa(NULL)
- , fTRDTriggerAnalysis(NULL)
+ , fTRDTriggerAnalysismb(NULL)
+ , fTRDTriggerAnalysistrg(NULL)
, fPIDpreselect(NULL)
, fCuts(NULL)
, fTaggedTrackCuts(NULL)
, fBackgroundSubtraction(NULL)
, fTRDTrigger(kFALSE)
, fWhichTRDTrigger(0)
+ , fV0Tagger(NULL)
, fQA(NULL)
, fOutput(NULL)
, fHistMCQA(NULL)
, fPlugins(0)
, fCollisionSystem(3)
, fFillSignalOnly(kTRUE)
+ , fRejectMCFakeTracks(kFALSE)
, fFillNoCuts(kFALSE)
- , fApplyCutAOD(kTRUE)
, fBackGroundFactorApply(kFALSE)
, fRemovePileUp(kFALSE)
, fIdentifiedAsPileUp(kFALSE)
, fTriggerAnalysis(NULL)
, fPID(NULL)
, fPIDqa(NULL)
- , fTRDTriggerAnalysis(NULL)
+ , fTRDTriggerAnalysismb(NULL)
+ , fTRDTriggerAnalysistrg(NULL)
, fPIDpreselect(NULL)
, fCuts(NULL)
, fTaggedTrackCuts(NULL)
, fBackgroundSubtraction(NULL)
, fTRDTrigger(kFALSE)
, fWhichTRDTrigger(0)
+ , fV0Tagger(NULL)
, fQA(NULL)
, fOutput(NULL)
, fHistMCQA(NULL)
DefineOutput(1, TList::Class());
DefineOutput(2, TList::Class());
+ fV0Tagger = new AliHFEV0taginfo("Tagger");
fPID = new AliHFEpid("hfePid");
fPIDqa = new AliHFEpidQAmanager;
fVarManager = new AliHFEvarManager("hfeVarManager");
fAnalysisUtils = new AliAnalysisUtils;
- fTRDTriggerAnalysis = new AliTRDTriggerAnalysis();
+ fTRDTriggerAnalysismb = new AliTRDTriggerAnalysis();
+ fTRDTriggerAnalysistrg = new AliTRDTriggerAnalysis();
+ fTRDTriggerAnalysistrg->SetRequireMatchElectron(kTRUE);
memset(fElecBackgroundFactor, 0, sizeof(Double_t) * kElecBgSpecies * kBgPtBins * kCentBins * kBgLevels);
memset(fkBackGroundFactorArray, 0, sizeof(TF1 *) * 12);
, fPlugins(0)
, fCollisionSystem(ref.fCollisionSystem)
, fFillSignalOnly(ref.fFillSignalOnly)
+ , fRejectMCFakeTracks(ref.fRejectMCFakeTracks)
, fFillNoCuts(ref.fFillNoCuts)
- , fApplyCutAOD(ref.fApplyCutAOD)
, fBackGroundFactorApply(ref.fBackGroundFactorApply)
, fRemovePileUp(ref.fRemovePileUp)
, fIdentifiedAsPileUp(ref.fIdentifiedAsPileUp)
, fTriggerAnalysis(NULL)
, fPID(NULL)
, fPIDqa(NULL)
- , fTRDTriggerAnalysis(NULL)
+ , fTRDTriggerAnalysismb(NULL)
+ , fTRDTriggerAnalysistrg(NULL)
, fPIDpreselect(NULL)
, fCuts(NULL)
, fTaggedTrackCuts(NULL)
, fBackgroundSubtraction(NULL)
, fTRDTrigger(ref.fTRDTrigger)
, fWhichTRDTrigger(ref.fWhichTRDTrigger)
+ , fV0Tagger(NULL)
, fQA(NULL)
, fOutput(NULL)
, fHistMCQA(NULL)
target.fPlugins = fPlugins;
target.fCollisionSystem = fCollisionSystem;
target.fFillSignalOnly = fFillSignalOnly;
+ target.fRejectMCFakeTracks = fRejectMCFakeTracks;
target.fFillNoCuts = fFillNoCuts;
- target.fApplyCutAOD = fApplyCutAOD;
target.fBackGroundFactorApply = fBackGroundFactorApply;
target.fRemovePileUp = fRemovePileUp;
target.fIdentifiedAsPileUp = fIdentifiedAsPileUp;
target.fTriggerAnalysis = fTriggerAnalysis;
target.fPID = fPID;
target.fPIDqa = fPIDqa;
- target.fTRDTriggerAnalysis = fTRDTriggerAnalysis;
+ target.fTRDTriggerAnalysismb = fTRDTriggerAnalysismb;
+ target.fTRDTriggerAnalysistrg = fTRDTriggerAnalysistrg;
target.fPIDpreselect = fPIDpreselect;
target.fCuts = fCuts;
target.fTaggedTrackCuts = fTaggedTrackCuts;
target.fBackgroundSubtraction = fBackgroundSubtraction;
target.fTRDTrigger = fTRDTrigger;
target.fWhichTRDTrigger = fWhichTRDTrigger;
+ target.fV0Tagger = fV0Tagger;
target.fQA = fQA;
target.fOutput = fOutput;
target.fHistMCQA = fHistMCQA;
if(fPID) delete fPID;
if(fPIDpreselect) delete fPIDpreselect;
if(fVarManager) delete fVarManager;
- if(fTRDTriggerAnalysis) delete fTRDTriggerAnalysis;
+ if(fTRDTriggerAnalysismb) delete fTRDTriggerAnalysismb;
+ if(fTRDTriggerAnalysistrg) delete fTRDTriggerAnalysistrg;
if(fCFM) delete fCFM;
if(fTriggerAnalysis) delete fTriggerAnalysis;
if(fSignalCuts) delete fSignalCuts;
if(fBackgroundSubtraction) delete fBackgroundSubtraction;
if(fSpecialTrigger) delete fSpecialTrigger;
if(fAnalysisUtils) delete fAnalysisUtils;
+ if(fV0Tagger) delete fV0Tagger;
// Delete output objects only if we are not running in PROOF mode because otherwise this produces a crash during merging
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if(mgr && mgr->GetAnalysisType() != AliAnalysisManager::kProofAnalysis){
fQACollection->CreateTH1F("nElectron", "Number of electrons", 100, 0, 100);
fQACollection->CreateTH2F("radius", "Production Vertex", 100, 0.0, 5.0, 100, 0.0, 5.0);
fQACollection->CreateTH1F("nTriggerBit", "Histo Trigger Bit", 22, 0, 22);
+ fQACollection->CreateTH2F("TriggerAnalysis","TRD Trigger Analysis",10,0.,10.,10,0.,10.);
+ fQACollection->CreateTH1F("Filterbegin", "AOD filter of tracks after all cuts", 21, -1, 20);
+ fQACollection->CreateTH1F("Filterend", "AOD filter of tracks after all cuts", 21, -1, 20);
+ fQACollection->CreateTH2F("Kinkbefore", "Kink status before filter; p_{T} (GeV/c); kink status", 100, 0., 20., 3, -0.5, 2.5);
+ fQACollection->CreateTH2F("Kinkafter", "Kink status after filter; p_{T} (GeV/c); kink status", 100, 0., 20., 3, -0.5, 2.5);
+ fQACollection->CreateTH1F("HFPuzzle", "Source definition for electrons from HF", 11, -0.5, 10.5);
InitHistoITScluster();
InitContaminationQA();
fPID->SortDetectors();
// Background subtraction-------------------------------------------------------------------
- if (GetPlugin(kNonPhotonicElectron)) {
+ if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) {
if(!fBackgroundSubtraction) fBackgroundSubtraction = new AliHFENonPhotonicElectron();
if(IsAODanalysis()) fBackgroundSubtraction->SetAOD(kTRUE);
fBackgroundSubtraction->Init();
fTaggedTrackAnalysis = new AliHFEtaggedTrackAnalysis(Form("taggedTrackAnalysis%s", GetName()));
fTaggedTrackAnalysis->SetCuts(fTaggedTrackCuts);
fTaggedTrackAnalysis->SetClean(fCleanTaggedTrack);
+ if(IsAODanalysis()) fTaggedTrackAnalysis->SetAOD();
AliHFEvarManager *varManager = fTaggedTrackAnalysis->GetVarManager();
TObjArray *array = fVarManager->GetVariables();
Int_t nvars = array->GetEntriesFast();
}
fSignalCuts->SetMCAODInfo(fAODArrayMCInfo);
// Background subtraction-------------------------------------------------------------------
- if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->SetAODArrayMCInfo(fAODArrayMCInfo);
+ if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->SetAODArrayMCInfo(fAODArrayMCInfo);
//------------------------------------------------------------------------------------------
}
if(fPIDpreselect) fPIDpreselect->SetPIDResponse(pidResponse);
// Background subtraction-------------------------------------------------------------------
- if(GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->InitRun(fInputEvent,pidResponse);
+ if(GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->InitRun(fInputEvent,pidResponse);
//------------------------------------------------------------------------------------------
// Event loop
fCFM->SetMCEventInfo(fMCEvent);
// fCFM->CheckEventCuts(AliCFManager::kEvtRecCuts, fESD);
} else {
+ fMCQA->SetMCArray(fAODArrayMCInfo);
+
+ if(!((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0))){ //kStepMCGeneratedZOutNoPileUpCentralityFine
+ if (HasMCData() && IsQAOn(kMCqa)) {
+ AliDebug(2, "Running MC QA");
+
+ fMCQA->SetCentrality(fCentralityF);
+ fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));
+
+ if(IsPbPb()) { fMCQA->SetPbPb();}
+ else
+ {
+ if(fisppMultiBin) fMCQA->SetPPMultiBin();
+ else fMCQA->SetPP();
+ }
+ fMCQA->Init();
+
+ //fMCQA->GetMesonKine();
+
+ // loop over all tracks for decayed electrons
+ AliAODMCParticle * mcpart;
+ for (Int_t igen = 0; igen < fAODArrayMCInfo->GetEntriesFast(); igen++){
+ mcpart = dynamic_cast<AliAODMCParticle *>(fAODArrayMCInfo->At(igen));
+ if(!mcpart) continue;
+ fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kCharm, AliHFEmcQA::kElectronPDG); // no accept cut
+ fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kBeauty, AliHFEmcQA::kElectronPDG); // no accept cut
+ fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kOthers, AliHFEmcQA::kElectronPDG); // no accept cut
+ }
+
+ } // end of MC QA loop
+ }
+
fCFM->SetMCEventInfo(fInputEvent);
}
// Run MC loop
// Set magnetic field if V0 task on
if(fTaggedTrackAnalysis) {
+ // Tag all v0s in current event
+ if(fV0Tagger){
+ fV0Tagger->Reset();
+ fV0Tagger->TagV0Tracks(fESD);
+ }
fTaggedTrackAnalysis->SetMagneticField(fESD->GetMagneticField());
fTaggedTrackAnalysis->SetCentrality(fCentralityF);
if(IsPbPb()) fTaggedTrackAnalysis->SetPbPb();
else {
- if(IspPb()) fTaggedTrackAnalysis->SetpPb();
- else fTaggedTrackAnalysis->SetPP();
+ if(IspPb()) fTaggedTrackAnalysis->SetpPb();
+ else fTaggedTrackAnalysis->SetPP();
}
-
}
// Do event Normalization
// Loop ESD
//
AliDebug(3, Form("Number of Tracks: %d", fESD->GetNumberOfTracks()));
+ Bool_t kinkmother(kFALSE), kinkdaughter(kFALSE); Double_t kinkstatus(0);
for(Int_t itrack = 0; itrack < fESD->GetNumberOfTracks(); itrack++){
AliDebug(4, "New ESD track");
track = fESD->GetTrack(itrack);
track->SetESDEvent(fESD);
+ kinkmother = track->GetKinkIndex(0) < 0; kinkdaughter = track->GetKinkIndex(0) > 0;
+ kinkstatus = 0.;
+ if(kinkmother) kinkstatus = 1.;
+ else if(kinkdaughter) kinkstatus = 2.;
// fill counts of v0-identified particles
- 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;
+ AliPID::EParticleType v0pid = fV0Tagger ? fV0Tagger->GetV0Info(track->GetID()) : AliPID::kUnknown;
// here the tagged track analysis will run
- if(fTaggedTrackAnalysis && v0pid > -1){
+ if(fTaggedTrackAnalysis && v0pid != AliPID::kUnknown){
AliDebug(1, Form("Track identified as %s", AliPID::ParticleName(v0pid)));
fTaggedTrackAnalysis->ProcessTrack(track, v0pid);
AliDebug(1, "V0 PID done");
if(!(mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(track->GetLabel()))))) continue;
if(fFillSignalOnly && !fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, mctrack)) signal = kFALSE;
+ if(fRejectMCFakeTracks && IsMCFakeTrack(track)) signal = kFALSE;
else AliDebug(3, "Signal Electron");
// Fill K pt for Ke3 contributions
// RecKine: ITSTPC cuts
if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;
-
+ fQACollection->Fill("Kinkbefore", track->Pt(), kinkstatus);
// RecPrim
if(fRejectKinkMother) {
if(track->GetKinkIndex(0) != 0) continue; } // Quick and dirty fix to reject both kink mothers and daughters
if(!ProcessCutStep(AliHFEcuts::kStepRecPrim, track)) continue;
+ fQACollection->Fill("Kinkafter", track->Pt(), kinkstatus);
// HFEcuts: ITS layers cuts
if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsITS, track)) continue;
if (GetPlugin(kNonPhotonicElectron)) {
Int_t indexmother = -1;
Int_t mcsource = -1;
+ Int_t mcQAsource = -1;
+ Double_t weightNonPhotonicFactor = 1.;
if(HasMCData()){
mcsource = fBackgroundSubtraction->FindMother(mctrack->GetLabel(),indexmother);
+ if(fBackgroundSubtraction->GetLevelBack()>=0) {
+ if(fMCQA) {
+ mcQAsource = fMCQA->GetElecSource(mctrack);
+ weightNonPhotonicFactor = TMath::Abs(fMCQA->GetWeightFactor(mctrack, fBackgroundSubtraction->GetLevelBack())); // positive:conversion e, negative: nonHFE
+ }
+ }
}
- fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, 1, fCentralityF, -1, mcsource, indexmother);
+ fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, weightNonPhotonicFactor, fCentralityF, -1, mcsource, indexmother,mcQAsource);
}
//-----------------------------------------------------------------------------------------------------------------
AliError("AOD Event required for AOD Analysis");
return;
}
+
+ // Set magnetic field if V0 task on
+ if(fTaggedTrackAnalysis) {
+ // Tag all v0s in current event
+ if(fV0Tagger){
+ fV0Tagger->Reset();
+ fV0Tagger->TagV0Tracks(fAOD);
+ }
+ fTaggedTrackAnalysis->SetMagneticField(fAOD->GetMagneticField());
+ fTaggedTrackAnalysis->SetCentrality(fCentralityF);
+ if(IsPbPb()) fTaggedTrackAnalysis->SetPbPb();
+ else {
+ if(IspPb()) fTaggedTrackAnalysis->SetpPb();
+ else fTaggedTrackAnalysis->SetPP();
+ }
+ }
//printf("Will fill\n");
//
//printf("Number of kink mother in the events %d\n",numberofmotherkink);
// Background subtraction-------------------------------------------------------------------
- if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent, fCentralityF);
+ if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent, fCentralityF);
//------------------------------------------------------------------------------------------
// Loop over tracks
Bool_t signal;
//printf("Number of track %d\n",(Int_t) fAOD->GetNumberOfTracks());
+ Bool_t kinkmother(kFALSE), kinkdaughter(kFALSE); Double_t kinkstatus(0);
for(Int_t itrack = 0; itrack < fAOD->GetNumberOfTracks(); itrack++){
+ kinkmother=kFALSE;
+ kinkdaughter=kFALSE;
+ kinkstatus = 0.;
track = fAOD->GetTrack(itrack); mctrack = NULL;
if(!track) continue;
+
+ for(int ivx = 0; ivx < numberofmotherkink; ivx++){
+ if(track->GetID() == listofmotherkink[ivx]){
+ kinkmother = kTRUE;
+ break;
+ }
+ }
+ AliAODVertex *pvx = track->GetProdVertex();
+ if(pvx && (pvx->GetType() == AliAODVertex::kKink)) kinkdaughter = kTRUE;
+ kinkstatus = 0.;
+ if(kinkmother) kinkstatus = 1.;
+ else if(kinkdaughter) kinkstatus = 2.;
+
+ // fill counts of v0-identified particles
+ AliPID::EParticleType v0pid = fV0Tagger ? fV0Tagger->GetV0Info(track->GetID()) : AliPID::kUnknown;
+ // here the tagged track analysis will run
+ if(fTaggedTrackAnalysis && v0pid != AliPID::kUnknown){
+ AliDebug(1, Form("Track identified as %s", AliPID::ParticleName(v0pid)));
+ fTaggedTrackAnalysis->ProcessTrack(track, v0pid);
+ AliDebug(1, "V0 PID done");
+ }
signal = kTRUE;
if(HasMCData()){
-
Int_t label = TMath::Abs(track->GetLabel());
if(label && label < fAODArrayMCInfo->GetEntriesFast())
mctrack = dynamic_cast<AliAODMCParticle *>(fAODArrayMCInfo->At(label));
if(fFillSignalOnly && !fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, mctrack)) signal = kFALSE;
+ if(fRejectMCFakeTracks && IsMCFakeTrack(track)) signal = kFALSE;
}
fVarManager->NewTrack(track, mctrack, fCentralityF, -1, signal);
}
}
- if(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;
+ // begin AOD QA
+ fQACollection->Fill("Filterbegin", -1);
+ for(Int_t k=0; k<20; k++) {
+ Int_t u = 1<<k;
+ if((track->TestFilterBit(u))) {
+ fQACollection->Fill("Filterbegin", k);
}
+ }
+
+ // RecKine: ITSTPC cuts
+ if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;
+
+ fQACollection->Fill("Kinkbefore", track->Pt(), kinkstatus);
+ // Reject kink mother
+ if(fRejectKinkMother) {
+ Bool_t kinkmotherpass = kTRUE;
+ for(Int_t ikinkmother = 0; ikinkmother < numberofmotherkink; ikinkmother++) {
+ if(track->GetID() == listofmotherkink[ikinkmother]) {
+ kinkmotherpass = kFALSE;
+ continue;
+ }
+ }
+ if(!kinkmotherpass) continue;
+ }
+
+ // RecPrim
+ if(!ProcessCutStep(AliHFEcuts::kStepRecPrim, track)) continue;
+ fQACollection->Fill("Kinkafter", track->Pt(), kinkstatus);
+
+ // HFEcuts: ITS layers cuts
+ if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsITS, track)) 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;
+ // HFE cuts: TOF PID and mismatch flag
+ if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTOF, track)) continue;
- // HFEcuts: Nb of tracklets TRD0
- if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTRD, 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")) {
}
if(HasMCData()){
+
+ if(fMCQA && signal){
+ fMCQA->SetCentrality(fCentralityF);
+ if(mctrack && (TMath::Abs(mctrack->GetPdgCode()) == 11)){
+ Double_t weightElecBgV0[kBgLevels] = {0.,0.,0.};
+ for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
+ weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE
+ }
+ if(weightElecBgV0[0]>0) {
+ fVarManager->FillContainer(fContainer, "conversionElecs", 3, kFALSE, weightElecBgV0[0]);
+ fVarManager->FillContainer(fContainer, "conversionElecs", 4, kTRUE, weightElecBgV0[0]);
+ }
+ else if(weightElecBgV0[0]<0) {
+ fVarManager->FillContainer(fContainer, "mesonElecs", 3, kFALSE, -1*weightElecBgV0[0]);
+ fVarManager->FillContainer(fContainer, "mesonElecs", 4, kTRUE, -1*weightElecBgV0[0]);
+ }
+ }
+ }
+
Double_t hfeimpactR4all=0., hfeimpactnsigmaR4all=0.;
Int_t sourceDca =-1;
if(mctrack && (TMath::Abs(mctrack->GetPdgCode()) == 211)){
// we will do PID here as soon as possible
// Background subtraction----------------------------------------------------------------------------------------------
- if (GetPlugin(kNonPhotonicElectron)) {
+ if (GetPlugin(kNonPhotonicElectron)&&!GetPlugin(kNonPhotonicElectronBeauty)) {
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);
+ Int_t mcsource = -1;
+ Int_t mcQAsource = -1;
+ Double_t weightNonPhotonicFactor = 1.;
+ //printf("weight %f \n",weightNonPhotonicFactor);
+ if(HasMCData() && mctrack){
+ mcsource = fBackgroundSubtraction->FindMother(TMath::Abs(track->GetLabel()),indexmother);
+ if(fBackgroundSubtraction->GetLevelBack()>=0) {
+ if(fMCQA) {
+ mcQAsource = fMCQA->GetElecSource(mctrack);
+ weightNonPhotonicFactor = TMath::Abs(fMCQA->GetWeightFactor(mctrack, fBackgroundSubtraction->GetLevelBack())); // positive:conversion e, negative: nonHFE
+ }
+ }
+ }
+ fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, weightNonPhotonicFactor, fCentralityF, -1,mcsource, indexmother,mcQAsource);
}
//---------------------------------------------------------------------------------------------------------------------
// weightBackGround as special weight
fVarManager->FillContainer(fContainer, "hadronicBackground", 2, kFALSE, fWeightBackGround);
}
+
+ fVarManager->FillContainer(fContainer, "recTrackContDEReco", AliHFEcuts::kStepHFEcutsDca, kFALSE);
+ fVarManager->FillContainer(fContainer, "recTrackContDEMC", AliHFEcuts::kStepHFEcutsDca, kTRUE);
+ fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterDE"));
+ }
+ }
+
+ // Background subtraction----------------------------------------------------------------------------------------------
+ if (!GetPlugin(kNonPhotonicElectron)&&GetPlugin(kNonPhotonicElectronBeauty)) {
+ Int_t indexmother = -1;
+ Int_t mcsource = -1;
+ Int_t mcQAsource = -1;
+ Double_t weightNonPhotonicFactor = 1.;
+ //printf("weight %f \n",weightNonPhotonicFactor);
+ if(HasMCData() && mctrack){
+ mcsource = fBackgroundSubtraction->FindMother(TMath::Abs(track->GetLabel()),indexmother);
+ if(fBackgroundSubtraction->GetLevelBack()>=0) {
+ if(fMCQA) {
+ mcQAsource = fMCQA->GetElecSource(mctrack);
+ weightNonPhotonicFactor = TMath::Abs(fMCQA->GetWeightFactor(mctrack, fBackgroundSubtraction->GetLevelBack())); // positive:conversion e, negative: nonHFE
+ }
+ }
}
+ fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, weightNonPhotonicFactor, fCentralityF, -1,mcsource, indexmother,mcQAsource);
}
+ //---------------------------------------------------------------------------------------------------------------------
+
}
// Background subtraction-------------------------------------------------------------------
- if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->CountPoolAssociated(fInputEvent, fCentralityF);
+ if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->CountPoolAssociated(fInputEvent, fCentralityF);
//------------------------------------------------------------------------------------------
fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);
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);
+ if(IsESDanalysis()){
+ if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCInAcceptance, track)) return kFALSE;
+ fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCInAcceptance, kFALSE);
+ }
return kTRUE;
}
case kDEstep: SETBIT(fPlugins, plug); break;
case kTaggedTrackAnalysis: SETBIT(fPlugins, plug); break;
case kNonPhotonicElectron: SETBIT(fPlugins, plug); break;
+ case kNonPhotonicElectronBeauty: SETBIT(fPlugins, plug); break;
default: AliError("Unknown Plugin");
};
}
//
Float_t fCentralityLimitstemp[12];
- Float_t fCentralityLimitsdefault[12]= {0.,5.,10., 20., 30., 40., 50., 60.,70.,80., 90., 100.};
+ Float_t fCentralityLimitsdefault[12]= {0.,5.,10., 20., 30., 40., 50., 60.,70.,80., 90., 100.00001};
if(!fPbPbUserCentralityBinning) memcpy(fCentralityLimitstemp,fCentralityLimitsdefault,sizeof(fCentralityLimitsdefault));
else memcpy(fCentralityLimitstemp,fCentralityLimits,sizeof(fCentralityLimitsdefault));
Bool_t cint8=kFALSE;
Bool_t cint7=kFALSE;
Bool_t cint5=kFALSE;
+ Bool_t cint8s=kFALSE;
+ Bool_t cint7s=kFALSE;
+ Bool_t cint7ppb=kFALSE;
Bool_t trdtrgevent=kFALSE;
+ // printf("TRIGGERS %s \n",ev->GetFiredTriggerClasses().Data());
+
+ fTRDTriggerAnalysismb->CalcTriggers(ev);
// mb selection of WU events
if(fWhichTRDTrigger==1)
{
- if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))
+// if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))
+ if((ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))||(ev->IsTriggerClassFired("CINT7WU-S-NOPF-ALL"))||(ev->IsTriggerClassFired("CINT8WU-S-NOPF-ALL")))
{
DrawTRDTrigger(ev);
+ DrawTRDTriggerAnalysis(ev);
return kTRUE;
}
else return kFALSE;
if(fWhichTRDTrigger==2)
{
cint8= ev->IsTriggerClassFired("CINT8WUHSE-B-NOPF-CENT");
- cint7= ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT");
+ cint7= ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT"); // pPb rare
+ cint7ppb= ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-ALL"); // pPb mb
+ cint8s= ev->IsTriggerClassFired("CINT7WUHSE-S-NOPF-CENT");
+ cint7s= ev->IsTriggerClassFired("CINT8WUHSE-S-NOPF-CENT");
cint5= (ev->IsTriggerClassFired("CINT5WU-B-NOPF-ALL")) &&
(ev->GetHeader()->GetL1TriggerInputs() & (1 << 10));
- if((cint7==kFALSE)&&(cint8==kFALSE)&&(cint5==kFALSE)) return kFALSE;
+// printf("hse trigger %i %i %i %i %i \n",cint7,cint7ppb,cint8,cint7s,cint8s);
+ if((cint7==kFALSE)&&(cint7ppb==kFALSE)&&(cint8==kFALSE)&&(cint7s==kFALSE)&&(cint8s==kFALSE)&&(cint5==kFALSE)) return kFALSE;
else
{
DrawTRDTrigger(ev);
+ DrawTRDTriggerAnalysis(ev);
return kTRUE;
}
}
if(fWhichTRDTrigger==3)
{
cint8= ev->IsTriggerClassFired("CINT8WUHQU-B-NOPF-CENT");
- cint7= ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT");
+ cint7= ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT"); // pPb rare
+ cint7ppb= ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-ALL"); // pPb mb
+ cint8s= ev->IsTriggerClassFired("CINT7WUHQU-S-NOPF-CENT");
+ cint7s= ev->IsTriggerClassFired("CINT8WUHQU-S-NOPF-CENT");
cint5= (ev->IsTriggerClassFired("CINT5WU-B-NOPF-ALL")) &&
(ev->GetHeader()->GetL1TriggerInputs() & (1 << 12));
- if((cint7==kFALSE)&&(cint8==kFALSE)&&(cint5==kFALSE)) return kFALSE;
+ // printf("hqu trigger %i %i %i %i %i \n",cint7,cint7ppb,cint8,cint7s,cint8s);
+ if((cint7==kFALSE)&&(cint7ppb==kFALSE)&&(cint8==kFALSE)&&(cint7s==kFALSE)&&(cint8s==kFALSE)&&(cint5==kFALSE)) return kFALSE;
else
{
DrawTRDTrigger(ev);
+ DrawTRDTriggerAnalysis(ev);
return kTRUE;
}
}
+ if(fWhichTRDTrigger==4)
+ {
+// printf("trigger %i %i \n", ev->GetHeader()->IsTriggerInputFired("1HSE"),(ev->GetHeader()->GetL1TriggerInputs() & (1 << 10))); // bug in IsTriggerInputFired; reported in savannah
+
+// if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))
+// {
+// Int_t trginput=0;
+// trginput=ev->GetHeader()->GetL1TriggerInputs() & (1 << 10); // HSE
+ // if(trginput==1024)
+// if(fTRDTriggerAnalysismb->CheckCondition(AliTRDTriggerAnalysis::kHSE))
+// if(fTRDTriggerAnalysismb->HasFired(AliTRDTriggerAnalysis::kHSE))
+ if(fTRDTriggerAnalysismb->HasTriggered(AliTRDTriggerAnalysis::kHSE))
+ {
+ DrawTRDTrigger(ev);
+ DrawTRDTriggerAnalysis(ev);
+ return kTRUE;
+ } else return kFALSE;
+ }// else return kFALSE;
+// }
+ if(fWhichTRDTrigger==5)
+ {
+// printf("trigger %i %i \n", ev->GetHeader()->IsTriggerInputFired("1HQU"),(ev->GetHeader()->GetL1TriggerInputs() & (1 << 12))); // bug in IsTriggerInputFired; reported in savannah
+// if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))
+// {
+
+// Int_t trginput=0;
+// trginput=ev->GetHeader()->GetL1TriggerInputs() & (1 << 12); //HQU
+ // printf("triggerinput %i \n",trginput);
+ // if(trginput==4096)
+// if(fTRDTriggerAnalysismb->CheckCondition(AliTRDTriggerAnalysis::kHQU))
+// if(fTRDTriggerAnalysismb->HasFired(AliTRDTriggerAnalysis::kHQU))
+ if(fTRDTriggerAnalysismb->HasTriggered(AliTRDTriggerAnalysis::kHQU))
+ {
+ DrawTRDTrigger(ev);
+ DrawTRDTriggerAnalysis(ev);
+ return kTRUE;
+ } else return kFALSE;
+ } //else return kFALSE;
+// }
return trdtrgevent;
// Check TRD trigger; pPb settings
//
- fTRDTriggerAnalysis->CalcTriggers(ev);
+ fTRDTriggerAnalysistrg->CalcTriggers(ev);
// HSE cleanup
if(fWhichTRDTrigger==6)
{
- if(!fTRDTriggerAnalysis->IsFired(AliTRDTriggerAnalysis::kHSE))
+ if(!fTRDTriggerAnalysistrg->HasTriggeredConfirmed(AliTRDTriggerAnalysis::kHSE))
{
return kFALSE;
}
else
{
- // DrawTRDTrigger(ev);
+ // DrawTRDTrigger(ev);
+ DrawTRDTriggerAnalysis(ev);
return kTRUE;
}
}
if(fWhichTRDTrigger==7)
{
- if(!fTRDTriggerAnalysis->IsFired(AliTRDTriggerAnalysis::kHQU))
+ if(!fTRDTriggerAnalysistrg->HasTriggeredConfirmed(AliTRDTriggerAnalysis::kHQU))
{
return kFALSE;
}
else
{
- // DrawTRDTrigger(ev);
+ // DrawTRDTrigger(ev);
+ DrawTRDTriggerAnalysis(ev);
return kTRUE;
}
}
// HSE or HQU cleanup
if(fWhichTRDTrigger==8)
{
- if((fTRDTriggerAnalysis->IsFired(AliTRDTriggerAnalysis::kHSE))||(fTRDTriggerAnalysis->IsFired(AliTRDTriggerAnalysis::kHQU)))
+ if((fTRDTriggerAnalysistrg->HasTriggeredConfirmed(AliTRDTriggerAnalysis::kHSE))||(fTRDTriggerAnalysistrg->HasTriggeredConfirmed(AliTRDTriggerAnalysis::kHQU)))
{
- // DrawTRDTrigger(ev);
+ // DrawTRDTrigger(ev);
+ DrawTRDTriggerAnalysis(ev);
return kTRUE;
}
else
}
+//___________________________________________________
void AliAnalysisTaskHFE::DrawTRDTrigger(AliESDEvent *ev) {
Int_t ntriggerbit=0;
if(ntriggerbit==0) fQACollection->Fill("nTriggerBit",1);
}
+
+
+//___________________________________________________
+void AliAnalysisTaskHFE::DrawTRDTriggerAnalysis(AliVEvent *ev) {
+
+ fTRDTriggerAnalysistrg->CalcTriggers(ev);
+ for(Int_t itrg=0;itrg<AliTRDTriggerAnalysis::kHlast;itrg++)
+ {
+ Int_t trdtrgstatus=0;
+ if(fTRDTriggerAnalysistrg->CheckCondition((AliTRDTriggerAnalysis::TRDTrigger_t) itrg))trdtrgstatus=1;
+ if(fTRDTriggerAnalysistrg->HasFired((AliTRDTriggerAnalysis::TRDTrigger_t) itrg))trdtrgstatus=2;
+ if(fTRDTriggerAnalysistrg->HasTriggered((AliTRDTriggerAnalysis::TRDTrigger_t) itrg))trdtrgstatus=3;
+ if(fTRDTriggerAnalysistrg->HasTriggeredConfirmed((AliTRDTriggerAnalysis::TRDTrigger_t) itrg))trdtrgstatus=4;
+ fQACollection->Fill("TriggerAnalysis",(Float_t)itrg,(Float_t)trdtrgstatus);
+ }
+}
+
+//___________________________________________________
+Bool_t AliAnalysisTaskHFE::IsMCFakeTrack(const AliVTrack *const trk) const {
+ //
+ // Check whether track is MC Fake track using the sign of the track label
+ //
+ return trk->GetLabel() < 0;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff