From: pchrist Date: Thu, 28 Jan 2010 22:13:56 +0000 (+0000) Subject: Adding the possibility to check the background contribution - more QA plots to come... X-Git-Url: http://git.uio.no/git/?a=commitdiff_plain;h=e56f08ed1cc5dbf2f276827f33b41725747b0924;p=u%2Fmrichter%2FAliRoot.git Adding the possibility to check the background contribution - more QA plots to come tomorrow --- diff --git a/PWG2/SPECTRA/AliAnalysisTaskProtonsQA.cxx b/PWG2/SPECTRA/AliAnalysisTaskProtonsQA.cxx index fd19a671791..68256430815 100644 --- a/PWG2/SPECTRA/AliAnalysisTaskProtonsQA.cxx +++ b/PWG2/SPECTRA/AliAnalysisTaskProtonsQA.cxx @@ -12,6 +12,7 @@ #include "AliMCEvent.h" #include "AliStack.h" #include "AliESDVertex.h" +#include "AliPhysicsSelection.h" #include "AliProtonQAAnalysis.h" #include "AliProtonAnalysisBase.h" @@ -140,19 +141,25 @@ void AliAnalysisTaskProtonsQA::Exec(Option_t *) { Printf("ERROR: Could not retrieve the stack"); return; } - - if(dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->IsEventTriggered(fESD,dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetTriggerMode())) { - fProtonQAAnalysis->RunVertexQA(header, - fESD); - const AliESDVertex *vertex = dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetVertex(fESD,dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetAnalysisMode(),dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetVxMax(),dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetVyMax(),dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetVzMax()); - if(vertex) { - fProtonQAAnalysis->RunQAAnalysis(stack, fESD, vertex); - fProtonQAAnalysis->RunMCAnalysis(stack); - fProtonQAAnalysis->RunPIDEfficiencyAnalysis(stack, fESD, vertex); - fProtonQAAnalysis->RunReconstructionEfficiencyAnalysis(fMC,fESD,vertex); - fProtonQAAnalysis->RunCutEfficiencyAnalysis(stack, fESD, vertex); - }//accepted vertex - }//triggered event + //online trigger + if(dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->IsEventTriggered(fESD,dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetTriggerMode())) { + //offline trigger + if(dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->IsOfflineTriggerUsed()) { + AliPhysicsSelection *gPhysicselection = dynamic_cast(dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetPhysicsSelectionObject()); + if(gPhysicselection->IsCollisionCandidate(fESD)) { + fProtonQAAnalysis->RunVertexQA(header, + fESD); + const AliESDVertex *vertex = dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetVertex(fESD,dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetAnalysisMode(),dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetVxMax(),dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetVyMax(),dynamic_cast(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetVzMax()); + if(vertex) { + fProtonQAAnalysis->RunQAAnalysis(stack, fESD, vertex); + fProtonQAAnalysis->RunMCAnalysis(stack); + fProtonQAAnalysis->RunPIDEfficiencyAnalysis(stack, fESD, vertex); + fProtonQAAnalysis->RunReconstructionEfficiencyAnalysis(fMC,fESD,vertex); + fProtonQAAnalysis->RunCutEfficiencyAnalysis(stack, fESD, vertex); + }//accepted vertex + }//offline trigger + }//offline trigger used + }//online trigger // Post output data. PostData(0, fList0); diff --git a/PWG2/SPECTRA/AliProtonAnalysis.cxx b/PWG2/SPECTRA/AliProtonAnalysis.cxx index 07d351ed396..3b303d99ca2 100644 --- a/PWG2/SPECTRA/AliProtonAnalysis.cxx +++ b/PWG2/SPECTRA/AliProtonAnalysis.cxx @@ -87,8 +87,6 @@ AliProtonAnalysis::AliProtonAnalysis(Int_t nbinsY, fQAAntiProtonsAcceptedList(0), fQAAntiProtonsRejectedList(0), fInitQAFlag(kFALSE) { //Default constructor - if(!fInitQAFlag) InitQA(); - fHistEvents = new TH1I("fHistEvents","Analyzed events",2,0.5,2.5); fHistEvents->GetXaxis()->SetBinLabel(1,"Analyzed events"); fHistEvents->GetXaxis()->SetBinLabel(2,"Events with (anti)protons"); @@ -137,6 +135,9 @@ AliProtonAnalysis::AliProtonAnalysis(Int_t nbinsY, kNSteps,2,iBin); fAntiProtonContainer->SetBinLimits(0,binLimY); //rapidity or eta fAntiProtonContainer->SetBinLimits(1,binLimPt); //pT + + //Initialize the QA + if(!fInitQAFlag) InitQA(); } //____________________________________________________________________// @@ -157,8 +158,6 @@ AliProtonAnalysis::AliProtonAnalysis(Int_t nbinsY, Double_t *gY, fQAAntiProtonsAcceptedList(0), fQAAntiProtonsRejectedList(0), fInitQAFlag(kFALSE) { //Default constructor - if(!fInitQAFlag) InitQA(); - fHistEvents = new TH1I("fHistEvents","Analyzed events",2,0.5,2.5); fHistEvents->GetXaxis()->SetBinLabel(1,"Analyzed events"); fHistEvents->GetXaxis()->SetBinLabel(2,"Events with (anti)protons"); @@ -197,6 +196,9 @@ AliProtonAnalysis::AliProtonAnalysis(Int_t nbinsY, Double_t *gY, kNSteps,2,iBin); fAntiProtonContainer->SetBinLimits(0,gY); //rapidity or eta fAntiProtonContainer->SetBinLimits(1,gPt); //pT + + //Initialize the QA + if(!fInitQAFlag) InitQA(); } //____________________________________________________________________// @@ -237,7 +239,6 @@ void AliProtonAnalysis::InitAnalysisHistograms(Int_t nbinsY, Int_t nbinsPt, Float_t fLowPt, Float_t fHighPt) { //Initializes the histograms - if(!fInitQAFlag) InitQA(); fNBinsY = nbinsY; fMinY = fLowY; fMaxY = fHighY; @@ -293,13 +294,15 @@ void AliProtonAnalysis::InitAnalysisHistograms(Int_t nbinsY, kNSteps,2,iBin); fAntiProtonContainer->SetBinLimits(0,binLimY); //rapidity fAntiProtonContainer->SetBinLimits(1,binLimPt); //pT + + //Initialize the QA + if(!fInitQAFlag) InitQA(); } //____________________________________________________________________// void AliProtonAnalysis::InitAnalysisHistograms(Int_t nbinsY, Double_t *gY, Int_t nbinsPt, Double_t *gPt) { //Initializes the histograms using asymmetric values - global tracking - if(!fInitQAFlag) InitQA(); fNBinsY = nbinsY; fMinY = gY[0]; fMaxY = gY[nbinsY]; @@ -346,6 +349,9 @@ void AliProtonAnalysis::InitAnalysisHistograms(Int_t nbinsY, Double_t *gY, kNSteps,2,iBin); fAntiProtonContainer->SetBinLimits(0,gY); //rapidity fAntiProtonContainer->SetBinLimits(1,gPt); //pT + + //Initialize the QA + if(!fInitQAFlag) InitQA(); } //____________________________________________________________________// @@ -715,39 +721,25 @@ void AliProtonAnalysis::Analyze(AliESDEvent* esd, gPt = tpcTrack->Pt(); gP = tpcTrack->P(); - if(fProtonAnalysisBase->IsAccepted(esd,vertex,track)) { - ((TH2F *)(fQA2DList->At(0)))->Fill(gP,track->GetTPCsignal()); - ((TH3F *)(fQA2DList->At(2)))->Fill(tpcTrack->Eta(), - tpcTrack->Phi()*180./TMath::Pi(), - npointsTPCdEdx); - ((TH3F *)(fQA2DList->At(4)))->Fill(tpcTrack->Eta(), - tpcTrack->Phi()*180./TMath::Pi(), - nClustersTPC); - ((TH3F *)(fQA2DList->At(6)))->Fill(gPt, - tpcTrack->Phi()*180./TMath::Pi(), - npointsTPCdEdx); - ((TH3F *)(fQA2DList->At(8)))->Fill(gPt, - tpcTrack->Phi()*180./TMath::Pi(), - nClustersTPC); - } - if(fProtonAnalysisBase->IsProton(track)) { - if(fProtonAnalysisBase->IsAccepted(esd,vertex,track)) { - ((TH2F *)(fQA2DList->At(1)))->Fill(gP,track->GetTPCsignal()); - ((TH3F *)(fQA2DList->At(3)))->Fill(tpcTrack->Eta(), - tpcTrack->Phi()*180./TMath::Pi(), - npointsTPCdEdx); - ((TH3F *)(fQA2DList->At(5)))->Fill(tpcTrack->Eta(), - tpcTrack->Phi()*180./TMath::Pi(), - nClustersTPC); - ((TH3F *)(fQA2DList->At(7)))->Fill(gPt, - tpcTrack->Phi()*180./TMath::Pi(), - npointsTPCdEdx); - ((TH3F *)(fQA2DList->At(9)))->Fill(gPt, - tpcTrack->Phi()*180./TMath::Pi(), - nClustersTPC); - } - FillQA(esd,vertex,track); - if(tpcTrack->Charge() > 0) { + if(fProtonAnalysisBase->IsPrimary(esd,vertex,track)) { + if(fProtonAnalysisBase->IsAccepted(esd,vertex,track)) { + ((TH2F *)(fQA2DList->At(0)))->Fill(gP,track->GetTPCsignal()); + ((TH3F *)(fQA2DList->At(2)))->Fill(tpcTrack->Eta(), + tpcTrack->Phi()*180./TMath::Pi(), + npointsTPCdEdx); + ((TH3F *)(fQA2DList->At(4)))->Fill(tpcTrack->Eta(), + tpcTrack->Phi()*180./TMath::Pi(), + nClustersTPC); + ((TH3F *)(fQA2DList->At(6)))->Fill(gPt, + tpcTrack->Phi()*180./TMath::Pi(), + npointsTPCdEdx); + ((TH3F *)(fQA2DList->At(8)))->Fill(gPt, + tpcTrack->Phi()*180./TMath::Pi(), + nClustersTPC); + }//quality cuts + }//primary cuts + if(tpcTrack->Charge() > 0) { + if(fProtonAnalysisBase->IsProton(track)) { nIdentifiedProtons += 1; if(fProtonAnalysisBase->GetEtaMode()) containerInput[0] = tpcTrack->Eta(); @@ -756,39 +748,72 @@ void AliProtonAnalysis::Analyze(AliESDEvent* esd, tpcTrack->Py(), tpcTrack->Pz()); containerInput[1] = gPt; - fProtonContainer->Fill(containerInput,0); - - if(!fProtonAnalysisBase->IsAccepted(esd,vertex,track)) continue;//track cuts - if(fProtonAnalysisBase->GetEtaMode()) - containerInput[0] = tpcTrack->Eta(); - else - containerInput[0] = fProtonAnalysisBase->Rapidity(tpcTrack->Px(), - tpcTrack->Py(), - tpcTrack->Pz()); - containerInput[1] = gPt; - fProtonContainer->Fill(containerInput,1); + fProtonContainer->Fill(containerInput,kStepIdentified); + if(fProtonAnalysisBase->IsPrimary(esd,vertex,track)) { + if(fProtonAnalysisBase->GetEtaMode()) + containerInput[0] = tpcTrack->Eta(); + else + containerInput[0] = fProtonAnalysisBase->Rapidity(tpcTrack->Px(), + tpcTrack->Py(), + tpcTrack->Pz()); + containerInput[1] = gPt; + fProtonContainer->Fill(containerInput,kStepIsPrimary); + + FillQA(esd,vertex,track); + + if(!fProtonAnalysisBase->IsAccepted(esd,vertex,track)) continue;//track cuts + + ((TH2F *)(fQA2DList->At(1)))->Fill(gP,track->GetTPCsignal()); + ((TH3F *)(fQA2DList->At(3)))->Fill(tpcTrack->Eta(), + tpcTrack->Phi()*180./TMath::Pi(), + npointsTPCdEdx); + ((TH3F *)(fQA2DList->At(5)))->Fill(tpcTrack->Eta(), + tpcTrack->Phi()*180./TMath::Pi(), + nClustersTPC); + ((TH3F *)(fQA2DList->At(7)))->Fill(gPt, + tpcTrack->Phi()*180./TMath::Pi(), + npointsTPCdEdx); + ((TH3F *)(fQA2DList->At(9)))->Fill(gPt, + tpcTrack->Phi()*180./TMath::Pi(), + nClustersTPC); + + + if(fProtonAnalysisBase->GetEtaMode()) + containerInput[0] = tpcTrack->Eta(); + else + containerInput[0] = fProtonAnalysisBase->Rapidity(tpcTrack->Px(), + tpcTrack->Py(), + tpcTrack->Pz()); + containerInput[1] = gPt; + fProtonContainer->Fill(containerInput,kStepSurvived); + + ((TH2F *)(fQA2DList->At(10)))->Fill(tpcTrack->Eta(), + tpcTrack->Phi()*180./TMath::Pi()); - if(!fProtonAnalysisBase->IsInPhaseSpace(track)) continue; //track outside the analyzed y-Pt - nSurvivedProtons += 1; - if(fProtonAnalysisBase->GetEtaMode()) { - fHistYPtProtons->Fill(tpcTrack->Eta(), - gPt); - containerInput[0] = tpcTrack->Eta(); - } - else { - fHistYPtProtons->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(), + if(!fProtonAnalysisBase->IsInPhaseSpace(track)) continue; //track outside the analyzed y-Pt + nSurvivedProtons += 1; + if(fProtonAnalysisBase->GetEtaMode()) { + fHistYPtProtons->Fill(tpcTrack->Eta(), + gPt); + containerInput[0] = tpcTrack->Eta(); + } + else { + fHistYPtProtons->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(), + tpcTrack->Py(), + tpcTrack->Pz()), + gPt); + //fill the container + containerInput[0] = fProtonAnalysisBase->Rapidity(tpcTrack->Px(), tpcTrack->Py(), - tpcTrack->Pz()), - gPt); - //fill the container - containerInput[0] = fProtonAnalysisBase->Rapidity(tpcTrack->Px(), - tpcTrack->Py(), - tpcTrack->Pz()); - } - containerInput[1] = gPt; - fProtonContainer->Fill(containerInput,2); - }//protons - else if(tpcTrack->Charge() < 0) { + tpcTrack->Pz()); + } + containerInput[1] = gPt; + fProtonContainer->Fill(containerInput,kStepInPhaseSpace); + }//primary cut + }//pid protons + }//charge cut + else if(tpcTrack->Charge() < 0) { + if(fProtonAnalysisBase->IsProton(track)) { nIdentifiedAntiProtons += 1; if(fProtonAnalysisBase->GetEtaMode()) containerInput[0] = tpcTrack->Eta(); @@ -797,77 +822,94 @@ void AliProtonAnalysis::Analyze(AliESDEvent* esd, tpcTrack->Py(), tpcTrack->Pz()); containerInput[1] = gPt; - fAntiProtonContainer->Fill(containerInput,0); - - if(!fProtonAnalysisBase->IsAccepted(esd,vertex,track)) continue;//track cuts - if(fProtonAnalysisBase->GetEtaMode()) - containerInput[0] = tpcTrack->Eta(); - else - containerInput[0] = fProtonAnalysisBase->Rapidity(tpcTrack->Px(), - tpcTrack->Py(), - tpcTrack->Pz()); - containerInput[1] = gPt; - fAntiProtonContainer->Fill(containerInput,1); + fAntiProtonContainer->Fill(containerInput,kStepIdentified); + if(fProtonAnalysisBase->IsPrimary(esd,vertex,track)) { + if(fProtonAnalysisBase->GetEtaMode()) + containerInput[0] = tpcTrack->Eta(); + else + containerInput[0] = fProtonAnalysisBase->Rapidity(tpcTrack->Px(), + tpcTrack->Py(), + tpcTrack->Pz()); + containerInput[1] = gPt; + fAntiProtonContainer->Fill(containerInput,kStepIsPrimary); + + FillQA(esd,vertex,track); + + if(!fProtonAnalysisBase->IsAccepted(esd,vertex,track)) continue;//track cuts + + ((TH2F *)(fQA2DList->At(1)))->Fill(gP,track->GetTPCsignal()); + ((TH3F *)(fQA2DList->At(3)))->Fill(tpcTrack->Eta(), + tpcTrack->Phi()*180./TMath::Pi(), + npointsTPCdEdx); + ((TH3F *)(fQA2DList->At(5)))->Fill(tpcTrack->Eta(), + tpcTrack->Phi()*180./TMath::Pi(), + nClustersTPC); + ((TH3F *)(fQA2DList->At(7)))->Fill(gPt, + tpcTrack->Phi()*180./TMath::Pi(), + npointsTPCdEdx); + ((TH3F *)(fQA2DList->At(9)))->Fill(gPt, + tpcTrack->Phi()*180./TMath::Pi(), + nClustersTPC); + + + if(fProtonAnalysisBase->GetEtaMode()) + containerInput[0] = tpcTrack->Eta(); + else + containerInput[0] = fProtonAnalysisBase->Rapidity(tpcTrack->Px(), + tpcTrack->Py(), + tpcTrack->Pz()); + containerInput[1] = gPt; + fAntiProtonContainer->Fill(containerInput,kStepSurvived); + + ((TH2F *)(fQA2DList->At(11)))->Fill(tpcTrack->Eta(), + tpcTrack->Phi()*180./TMath::Pi()); - if(!fProtonAnalysisBase->IsInPhaseSpace(track)) continue; //track outside the analyzed y-Pt - nSurvivedAntiProtons += 1; - if(fProtonAnalysisBase->GetEtaMode()) { - fHistYPtAntiProtons->Fill(tpcTrack->Eta(), - gPt); - containerInput[0] = tpcTrack->Eta(); - } - else { - fHistYPtAntiProtons->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(), - tpcTrack->Py(), - tpcTrack->Pz()), - gPt); - //fill the container - containerInput[0] = fProtonAnalysisBase->Rapidity(tpcTrack->Px(), - tpcTrack->Py(), - tpcTrack->Pz()); - } - containerInput[1] = gPt; - fAntiProtonContainer->Fill(containerInput,2); - }//antiprotons - }//proton check + if(!fProtonAnalysisBase->IsInPhaseSpace(track)) continue; //track outside the analyzed y-Pt + nSurvivedAntiProtons += 1; + if(fProtonAnalysisBase->GetEtaMode()) { + fHistYPtAntiProtons->Fill(tpcTrack->Eta(), + gPt); + containerInput[0] = tpcTrack->Eta(); + } + else { + fHistYPtAntiProtons->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(), + tpcTrack->Py(), + tpcTrack->Pz()), + gPt); + //fill the container + containerInput[0] = fProtonAnalysisBase->Rapidity(tpcTrack->Px(), + tpcTrack->Py(), + tpcTrack->Pz()); + } + containerInput[1] = gPt; + fAntiProtonContainer->Fill(containerInput,kStepInPhaseSpace); + }//primary cut + }//pid protons + }//charge cut }//TPC only tracks else if(fProtonAnalysisBase->GetAnalysisMode() == AliProtonAnalysisBase::kGlobal) { gPt = track->Pt(); gP = track->P(); - - if(fProtonAnalysisBase->IsAccepted(esd,vertex,track)) { - ((TH2F *)(fQA2DList->At(0)))->Fill(gP,track->GetTPCsignal()); - ((TH3F *)(fQA2DList->At(2)))->Fill(track->Eta(), - track->Phi()*180./TMath::Pi(), - npointsTPCdEdx); - ((TH3F *)(fQA2DList->At(4)))->Fill(track->Eta(), - track->Phi()*180./TMath::Pi(), - nClustersTPC); - ((TH3F *)(fQA2DList->At(6)))->Fill(gPt, - track->Phi()*180./TMath::Pi(), - npointsTPCdEdx); - ((TH3F *)(fQA2DList->At(8)))->Fill(gPt, - track->Phi()*180./TMath::Pi(), - nClustersTPC); - } - if(fProtonAnalysisBase->IsProton(track)) { + + if(fProtonAnalysisBase->IsPrimary(esd,vertex,track)) { if(fProtonAnalysisBase->IsAccepted(esd,vertex,track)) { - ((TH2F *)(fQA2DList->At(1)))->Fill(gP,track->GetTPCsignal()); - ((TH3F *)(fQA2DList->At(3)))->Fill(track->Eta(), - track->Phi()*180./TMath::Pi(), - npointsTPCdEdx); - ((TH3F *)(fQA2DList->At(5)))->Fill(track->Eta(), - track->Phi()*180./TMath::Pi(), - nClustersTPC); - ((TH3F *)(fQA2DList->At(7)))->Fill(gPt, - track->Phi()*180./TMath::Pi(), - npointsTPCdEdx); - ((TH3F *)(fQA2DList->At(9)))->Fill(gPt, - track->Phi()*180./TMath::Pi(), - nClustersTPC); - } - FillQA(esd,vertex,track); - if(track->Charge() > 0) { + ((TH2F *)(fQA2DList->At(0)))->Fill(gP,track->GetTPCsignal()); + ((TH3F *)(fQA2DList->At(2)))->Fill(track->Eta(), + track->Phi()*180./TMath::Pi(), + npointsTPCdEdx); + ((TH3F *)(fQA2DList->At(4)))->Fill(track->Eta(), + track->Phi()*180./TMath::Pi(), + nClustersTPC); + ((TH3F *)(fQA2DList->At(6)))->Fill(gPt, + track->Phi()*180./TMath::Pi(), + npointsTPCdEdx); + ((TH3F *)(fQA2DList->At(8)))->Fill(gPt, + track->Phi()*180./TMath::Pi(), + nClustersTPC); + }//quality cuts + }//primary cuts + if(track->Charge() > 0) { + if(fProtonAnalysisBase->IsProton(track)) { nIdentifiedProtons += 1; if(fProtonAnalysisBase->GetEtaMode()) containerInput[0] = track->Eta(); @@ -876,39 +918,72 @@ void AliProtonAnalysis::Analyze(AliESDEvent* esd, track->Py(), track->Pz()); containerInput[1] = gPt; - fProtonContainer->Fill(containerInput,0); - - if(!fProtonAnalysisBase->IsAccepted(esd,vertex,track)) continue;//track cuts - if(fProtonAnalysisBase->GetEtaMode()) - containerInput[0] = track->Eta(); - else - containerInput[0] = fProtonAnalysisBase->Rapidity(track->Px(), - track->Py(), - track->Pz()); - containerInput[1] = gPt; - fProtonContainer->Fill(containerInput,1); + fProtonContainer->Fill(containerInput,kStepIdentified); + if(fProtonAnalysisBase->IsPrimary(esd,vertex,track)) { + if(fProtonAnalysisBase->GetEtaMode()) + containerInput[0] = track->Eta(); + else + containerInput[0] = fProtonAnalysisBase->Rapidity(track->Px(), + track->Py(), + track->Pz()); + containerInput[1] = gPt; + fProtonContainer->Fill(containerInput,kStepIsPrimary); + + FillQA(esd,vertex,track); + + if(!fProtonAnalysisBase->IsAccepted(esd,vertex,track)) continue;//track cuts + + ((TH2F *)(fQA2DList->At(1)))->Fill(gP,track->GetTPCsignal()); + ((TH3F *)(fQA2DList->At(3)))->Fill(track->Eta(), + track->Phi()*180./TMath::Pi(), + npointsTPCdEdx); + ((TH3F *)(fQA2DList->At(5)))->Fill(track->Eta(), + track->Phi()*180./TMath::Pi(), + nClustersTPC); + ((TH3F *)(fQA2DList->At(7)))->Fill(gPt, + track->Phi()*180./TMath::Pi(), + npointsTPCdEdx); + ((TH3F *)(fQA2DList->At(9)))->Fill(gPt, + track->Phi()*180./TMath::Pi(), + nClustersTPC); + - if(!fProtonAnalysisBase->IsInPhaseSpace(track)) continue; //track outside the analyzed y-Pt - nSurvivedProtons += 1; - if(fProtonAnalysisBase->GetEtaMode()) { - fHistYPtProtons->Fill(track->Eta(), - gPt); - containerInput[0] = track->Eta(); - } - else { - fHistYPtProtons->Fill(fProtonAnalysisBase->Rapidity(track->Px(), + if(fProtonAnalysisBase->GetEtaMode()) + containerInput[0] = track->Eta(); + else + containerInput[0] = fProtonAnalysisBase->Rapidity(track->Px(), track->Py(), - track->Pz()), - gPt); - //fill the container - containerInput[0] = fProtonAnalysisBase->Rapidity(track->Px(), - track->Py(), - track->Pz()); - } - containerInput[1] = gPt; - fProtonContainer->Fill(containerInput,2); - }//protons - else if(track->Charge() < 0) { + track->Pz()); + containerInput[1] = gPt; + fProtonContainer->Fill(containerInput,kStepSurvived); + + ((TH2F *)(fQA2DList->At(10)))->Fill(track->Eta(), + track->Phi()*180./TMath::Pi()); + + if(!fProtonAnalysisBase->IsInPhaseSpace(track)) continue; //track outside the analyzed y-Pt + nSurvivedProtons += 1; + if(fProtonAnalysisBase->GetEtaMode()) { + fHistYPtProtons->Fill(track->Eta(), + gPt); + containerInput[0] = track->Eta(); + } + else { + fHistYPtProtons->Fill(fProtonAnalysisBase->Rapidity(track->Px(), + track->Py(), + track->Pz()), + gPt); + //fill the container + containerInput[0] = fProtonAnalysisBase->Rapidity(track->Px(), + track->Py(), + track->Pz()); + } + containerInput[1] = gPt; + fProtonContainer->Fill(containerInput,kStepInPhaseSpace); + }//primary cut + }//pid protons + }//charge cut + else if(track->Charge() < 0) { + if(fProtonAnalysisBase->IsProton(track)) { nIdentifiedAntiProtons += 1; if(fProtonAnalysisBase->GetEtaMode()) containerInput[0] = track->Eta(); @@ -917,40 +992,71 @@ void AliProtonAnalysis::Analyze(AliESDEvent* esd, track->Py(), track->Pz()); containerInput[1] = gPt; - fAntiProtonContainer->Fill(containerInput,0); + fAntiProtonContainer->Fill(containerInput,kStepIdentified); + if(fProtonAnalysisBase->IsPrimary(esd,vertex,track)) { + if(fProtonAnalysisBase->GetEtaMode()) + containerInput[0] = track->Eta(); + else + containerInput[0] = fProtonAnalysisBase->Rapidity(track->Px(), + track->Py(), + track->Pz()); + containerInput[1] = gPt; + fAntiProtonContainer->Fill(containerInput,kStepIsPrimary); + + FillQA(esd,vertex,track); + + if(!fProtonAnalysisBase->IsAccepted(esd,vertex,track)) continue;//track cuts + + ((TH2F *)(fQA2DList->At(1)))->Fill(gP,track->GetTPCsignal()); + ((TH3F *)(fQA2DList->At(3)))->Fill(track->Eta(), + track->Phi()*180./TMath::Pi(), + npointsTPCdEdx); + ((TH3F *)(fQA2DList->At(5)))->Fill(track->Eta(), + track->Phi()*180./TMath::Pi(), + nClustersTPC); + ((TH3F *)(fQA2DList->At(7)))->Fill(gPt, + track->Phi()*180./TMath::Pi(), + npointsTPCdEdx); + ((TH3F *)(fQA2DList->At(9)))->Fill(gPt, + track->Phi()*180./TMath::Pi(), + nClustersTPC); + - if(!fProtonAnalysisBase->IsAccepted(esd,vertex,track)) continue;//track cuts - if(fProtonAnalysisBase->GetEtaMode()) - containerInput[0] = track->Eta(); - else - containerInput[0] = fProtonAnalysisBase->Rapidity(track->Px(), - track->Py(), - track->Pz()); - containerInput[1] = gPt; - fAntiProtonContainer->Fill(containerInput,1); + if(fProtonAnalysisBase->GetEtaMode()) + containerInput[0] = track->Eta(); + else + containerInput[0] = fProtonAnalysisBase->Rapidity(track->Px(), + track->Py(), + track->Pz()); + containerInput[1] = gPt; + fAntiProtonContainer->Fill(containerInput,kStepSurvived); + + ((TH2F *)(fQA2DList->At(11)))->Fill(track->Eta(), + track->Phi()*180./TMath::Pi()); - if(!fProtonAnalysisBase->IsInPhaseSpace(track)) continue; //track outside the analyzed y-Pt - nSurvivedAntiProtons += 1; - if(fProtonAnalysisBase->GetEtaMode()) { - fHistYPtAntiProtons->Fill(track->Eta(), - gPt); - containerInput[0] = track->Eta(); - } - else { - fHistYPtAntiProtons->Fill(fProtonAnalysisBase->Rapidity(track->Px(), - track->Py(), - track->Pz()), - gPt); - //fill the container - containerInput[0] = fProtonAnalysisBase->Rapidity(track->Px(), - track->Py(), - track->Pz()); - } - containerInput[1] = gPt; - fAntiProtonContainer->Fill(containerInput,2); - }//antiprotons - }//proton check - }//combined tracking + if(!fProtonAnalysisBase->IsInPhaseSpace(track)) continue; //track outside the analyzed y-Pt + nSurvivedAntiProtons += 1; + if(fProtonAnalysisBase->GetEtaMode()) { + fHistYPtAntiProtons->Fill(track->Eta(), + gPt); + containerInput[0] = track->Eta(); + } + else { + fHistYPtAntiProtons->Fill(fProtonAnalysisBase->Rapidity(track->Px(), + track->Py(), + track->Pz()), + gPt); + //fill the container + containerInput[0] = fProtonAnalysisBase->Rapidity(track->Px(), + track->Py(), + track->Pz()); + } + containerInput[1] = gPt; + fAntiProtonContainer->Fill(containerInput,kStepInPhaseSpace); + }//primary cut + }//pid protons + }//charge cut + }//global tracking }//track loop if((nIdentifiedProtons > 0)||(nIdentifiedAntiProtons > 0)) @@ -1344,15 +1450,15 @@ void AliProtonAnalysis::InitQA() { //eta-phi-Npoints(dEdx) TH3F *gHistEtaPhiTPCdEdxNPoints = new TH3F("gHistEtaPhiTPCdEdxNPoints", ";#eta;#phi;N_{points}(TPC)", - fNBinsY,fMinY,fMaxY, - 100,0,360, + 18,-0.9,0.9, + 180,0,360, 100,0,200); gHistEtaPhiTPCdEdxNPoints->SetStats(kTRUE); fQA2DList->Add(gHistEtaPhiTPCdEdxNPoints); TH3F *gHistProtonsEtaPhiTPCdEdxNPoints = new TH3F("gHistProtonsEtaPhiTPCdEdxNPoints", ";#eta;#phi;N_{points}(TPC)", - fNBinsY,fMinY,fMaxY, - 100,0,360, + 18,-0.9,0.9, + 180,0,360, 100,0,200); gHistProtonsEtaPhiTPCdEdxNPoints->SetStats(kTRUE); fQA2DList->Add(gHistProtonsEtaPhiTPCdEdxNPoints); @@ -1360,15 +1466,15 @@ void AliProtonAnalysis::InitQA() { //eta-phi-Npoints TH3F *gHistEtaPhiTPCNPoints = new TH3F("gHistEtaPhiTPCNPoints", ";#eta;#phi;N_{points}(TPC)", - fNBinsY,fMinY,fMaxY, - 100,0,360, + 18,-0.9,0.9, + 180,0,360, 100,0,200); gHistEtaPhiTPCNPoints->SetStats(kTRUE); fQA2DList->Add(gHistEtaPhiTPCNPoints); TH3F *gHistProtonsEtaPhiTPCNPoints = new TH3F("gHistProtonsEtaPhiTPCNPoints", ";#eta;#phi;N_{points}(TPC)", - fNBinsY,fMinY,fMaxY, - 100,0,360, + 18,-0.9,0.9, + 180,0,360, 100,0,200); gHistProtonsEtaPhiTPCNPoints->SetStats(kTRUE); fQA2DList->Add(gHistProtonsEtaPhiTPCNPoints); @@ -1377,14 +1483,14 @@ void AliProtonAnalysis::InitQA() { TH3F *gHistPtPhiTPCdEdxNPoints = new TH3F("gHistPtPhiTPCdEdxNPoints", ";P_{T} [GeV/c];#phi;N_{points}(TPC)", fNBinsPt,fMinPt,fMaxPt, - 100,0,360, + 180,0,360, 100,0,200); gHistPtPhiTPCdEdxNPoints->SetStats(kTRUE); fQA2DList->Add(gHistPtPhiTPCdEdxNPoints); TH3F *gHistProtonsPtPhiTPCdEdxNPoints = new TH3F("gHistProtonsPtPhiTPCdEdxNPoints", ";P_{T} [GeV/c];#phi;N_{points}(TPC)", fNBinsPt,fMinPt,fMaxPt, - 100,0,360, + 180,0,360, 100,0,200); gHistProtonsPtPhiTPCdEdxNPoints->SetStats(kTRUE); fQA2DList->Add(gHistProtonsPtPhiTPCdEdxNPoints); @@ -1393,18 +1499,32 @@ void AliProtonAnalysis::InitQA() { TH3F *gHistPtPhiTPCNPoints = new TH3F("gHistPtPhiTPCNPoints", ";P_{T} [GeV/c];#phi;N_{points}(TPC)", fNBinsPt,fMinPt,fMaxPt, - 100,0,360, + 180,0,360, 100,0,200); gHistPtPhiTPCNPoints->SetStats(kTRUE); fQA2DList->Add(gHistPtPhiTPCNPoints); TH3F *gHistProtonsPtPhiTPCNPoints = new TH3F("gHistProtonsPtPhiTPCNPoints", ";P_{T} [GeV/c];#phi;N_{points}(TPC)", fNBinsPt,fMinPt,fMaxPt, - 100,0,360, + 180,0,360, 100,0,200); gHistProtonsPtPhiTPCNPoints->SetStats(kTRUE); fQA2DList->Add(gHistProtonsPtPhiTPCNPoints); + //eta-phi for protons & antiprotons + TH2F *gHistProtonsEtaPhi = new TH2F("gHistProtonsEtaPhi", + ";#eta;#phi", + 18,-0.9,0.9, + 180,0,360); + gHistProtonsEtaPhi->SetStats(kTRUE); + fQA2DList->Add(gHistProtonsEtaPhi); + TH2F *gHistAntiProtonsEtaPhi = new TH2F("gHistAntiProtonsEtaPhi", + ";#eta;#phi", + 18,-0.9,0.9, + 180,0,360); + gHistAntiProtonsEtaPhi->SetStats(kTRUE); + fQA2DList->Add(gHistAntiProtonsEtaPhi); + //========================================================// fQAProtonsAcceptedList = new TList(); fQAProtonsAcceptedList->SetName("fQAProtonsAcceptedList"); diff --git a/PWG2/SPECTRA/AliProtonAnalysis.h b/PWG2/SPECTRA/AliProtonAnalysis.h index 7e0793c5afd..45bc7585142 100644 --- a/PWG2/SPECTRA/AliProtonAnalysis.h +++ b/PWG2/SPECTRA/AliProtonAnalysis.h @@ -38,9 +38,10 @@ class AliProtonAnalysis : public TObject { public: enum { kStepIdentified = 0, - kStepSurvived = 1, - kStepInPhaseSpace = 2, - kNSteps = 3 + kStepIsPrimary = 1, + kStepSurvived = 2, + kStepInPhaseSpace = 3, + kNSteps = 4 }; AliProtonAnalysis(); AliProtonAnalysis(Int_t nbinsY, Float_t fLowY, Float_t fHighY, diff --git a/PWG2/SPECTRA/AliProtonAnalysisBase.cxx b/PWG2/SPECTRA/AliProtonAnalysisBase.cxx index 0937bf7287e..b9c6a40a2a8 100644 --- a/PWG2/SPECTRA/AliProtonAnalysisBase.cxx +++ b/PWG2/SPECTRA/AliProtonAnalysisBase.cxx @@ -40,10 +40,11 @@ ClassImp(AliProtonAnalysisBase) //____________________________________________________________________// AliProtonAnalysisBase::AliProtonAnalysisBase() : TObject(), fProtonAnalysisLevel("ESD"), fAnalysisMC(kFALSE), - fTriggerMode(kMB2), kUseOfflineTrigger(kFALSE), fPhysicsSelection(0), + fTriggerMode(kMB2), kUseOnlineTrigger(kFALSE), kUseOfflineTrigger(kFALSE), + fPhysicsSelection(0), fProtonAnalysisMode(kTPC), fProtonPIDMode(kBayesian), fAnalysisEtaMode(kFALSE), - fVxMax(100.), fVyMax(100.), fVzMax(100.), + fVxMax(100.), fVyMax(100.), fVzMax(100.), fMinNumOfContributors(0), fNBinsX(0), fMinX(0), fMaxX(0), fNBinsY(0), fMinY(0), fMaxY(0), fMinTPCClusters(0), fMinITSClusters(0), @@ -80,7 +81,6 @@ AliProtonAnalysisBase::AliProtonAnalysisBase() : fdEdxMean[i] = 0.0; fdEdxSigma[i] = 0.0; } - //fListVertexQA = new TList(); fListVertexQA->SetName("fListVertexQA"); TH1F *gHistVx = new TH1F("gHistVx", "Vx distribution;V_{x} [cm];Entries", @@ -110,6 +110,11 @@ AliProtonAnalysisBase::AliProtonAnalysisBase() : 100,-25.,25.); fListVertexQA->Add(gHistVzAccepted); + TH1F *gHistNumberOfContributors = new TH1F("gHistNumberOfContributors", + "Number of contributors;N_{contr.};Entries", + 100,0.,100.); + fListVertexQA->Add(gHistNumberOfContributors); + } @@ -169,11 +174,16 @@ Bool_t AliProtonAnalysisBase::IsInPhaseSpace(AliESDtrack* const track) { eta = track->Eta(); } - if((gP < fMinY) || (gP > fMaxY)) { + if((gPt < fMinY) || (gPt > fMaxY)) { if(fDebugMode) Printf("IsInPhaseSpace: Track rejected because it has a Pt value of %lf (accepted interval: %lf - %lf)",gPt,fMinY,fMaxY); return kFALSE; } + if((gP < fMinY) || (gP > fMaxY)) { + if(fDebugMode) + Printf("IsInPhaseSpace: Track rejected because it has a P value of %lf (accepted interval: %lf - %lf)",gP,fMinY,fMaxY); + return kFALSE; + } if(fAnalysisEtaMode) { if((eta < fMinX) || (eta > fMaxX)) { if(fDebugMode) @@ -459,10 +469,276 @@ Bool_t AliProtonAnalysisBase::IsAccepted(AliESDEvent *esd, return kTRUE; } +//____________________________________________________________________// +Bool_t AliProtonAnalysisBase::IsPrimary(AliESDEvent *esd, + const AliESDVertex *vertex, + AliESDtrack* track) { + // Checks if the track is a primary-like candidate + Double_t gPt = 0.0, gPx = 0.0, gPy = 0.0, gPz = 0.0; + Double_t dca[2] = {0.0,0.0}, cov[3] = {0.0,0.0,0.0}; //The impact parameters and their covariance. + Double_t dca3D = 0.0; + + if((fProtonAnalysisMode == kTPC)||(fProtonAnalysisMode == kHybrid)) { + AliExternalTrackParam *tpcTrack = (AliExternalTrackParam *)track->GetTPCInnerParam(); + if(!tpcTrack) { + gPt = 0.0; gPx = 0.0; gPy = 0.0; gPz = 0.0; + dca[0] = -100.; dca[1] = -100.; dca3D = -100.; + cov[0] = -100.; cov[1] = -100.; cov[2] = -100.; + } + else { + gPt = tpcTrack->Pt(); + gPx = tpcTrack->Px(); + gPy = tpcTrack->Py(); + gPz = tpcTrack->Pz(); + tpcTrack->PropagateToDCA(vertex, + esd->GetMagneticField(), + 100.,dca,cov); + } + }//standalone TPC or hybrid TPC approaches + else { + gPt = track->Pt(); + gPx = track->Px(); + gPy = track->Py(); + gPz = track->Pz(); + track->PropagateToDCA(vertex, + esd->GetMagneticField(), + 100.,dca,cov); + } + dca3D = TMath::Sqrt(TMath::Power(dca[0],2) + + TMath::Power(dca[1],2)); + + Int_t fIdxInt[200]; + Int_t nClustersITS = track->GetITSclusters(fIdxInt); + Int_t nClustersTPC = track->GetTPCclusters(fIdxInt); + + Float_t chi2PerClusterITS = -1; + if (nClustersITS!=0) + chi2PerClusterITS = track->GetITSchi2()/Float_t(nClustersITS); + Float_t chi2PerClusterTPC = -1; + if (nClustersTPC!=0) + chi2PerClusterTPC = track->GetTPCchi2()/Float_t(nClustersTPC); + + Double_t extCov[15]; + track->GetExternalCovariance(extCov); + + if(fPointOnITSLayer1Flag) { + if(!track->HasPointOnITSLayer(0)) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it doesn't have a point on the 1st ITS layer"); + return kFALSE; + } + } + if(fPointOnITSLayer2Flag) { + if(!track->HasPointOnITSLayer(1)) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it doesn't have a point on the 2nd ITS layer"); + return kFALSE; + } + } + if(fPointOnITSLayer3Flag) { + if(!track->HasPointOnITSLayer(2)) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it doesn't have a point on the 3rd ITS layer"); + return kFALSE; + } + } + if(fPointOnITSLayer4Flag) { + if(!track->HasPointOnITSLayer(3)) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it doesn't have a point on the 4th ITS layer"); + return kFALSE; + } + } + if(fPointOnITSLayer5Flag) { + if(!track->HasPointOnITSLayer(4)) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it doesn't have a point on the 5th ITS layer"); + return kFALSE; + } + } + if(fPointOnITSLayer6Flag) { + if(!track->HasPointOnITSLayer(5)) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it doesn't have a point on the 6th ITS layer"); + return kFALSE; + } + } + if(fMinITSClustersFlag) { + if(nClustersITS < fMinITSClusters) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has %d ITS points (min. requested: %d)",nClustersITS,fMinITSClusters); + return kFALSE; + } + } + if(fMaxChi2PerITSClusterFlag) { + if(chi2PerClusterITS > fMaxChi2PerITSCluster) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a chi2 per ITS cluster %lf (max. requested: %lf)",chi2PerClusterITS,fMaxChi2PerITSCluster); + return kFALSE; + } + } + if(fMinTPCClustersFlag) { + if(nClustersTPC < fMinTPCClusters) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has %d TPC clusters (min. requested: %d)",nClustersTPC,fMinTPCClusters); + return kFALSE; + } + } + if(fMaxChi2PerTPCClusterFlag) { + if(chi2PerClusterTPC > fMaxChi2PerTPCCluster) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a chi2 per TPC cluster %lf (max. requested: %lf)",chi2PerClusterTPC,fMaxChi2PerTPCCluster); + return kFALSE; + } + } + if(fMaxCov11Flag) { + if(extCov[0] > fMaxCov11) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a cov11 value of %lf (max. requested: %lf)",extCov[0],fMaxCov11); + return kFALSE; + } + } + if(fMaxCov22Flag) { + if(extCov[2] > fMaxCov22) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a cov22 value of %lf (max. requested: %lf)",extCov[2],fMaxCov22); + return kFALSE; + } + } + if(fMaxCov33Flag) { + if(extCov[5] > fMaxCov33) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a cov33 value of %lf (max. requested: %lf)",extCov[5],fMaxCov33); + return kFALSE; + } + } + if(fMaxCov44Flag) { + if(extCov[9] > fMaxCov44) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a cov44 value of %lf (max. requested: %lf)",extCov[9],fMaxCov44); + return kFALSE; + } + } + if(fMaxCov55Flag) { + if(extCov[14] > fMaxCov55) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a cov55 value of %lf (max. requested: %lf)",extCov[14],fMaxCov55); + return kFALSE; + } + } + if(fMaxSigmaToVertexFlag) { + if(GetSigmaToVertex(track) > fMaxSigmaToVertex) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a %lf sigmas to vertex (max. requested: %lf)",GetSigmaToVertex(track),fMaxSigmaToVertex); + return kFALSE; + } + } + if(fMaxSigmaToVertexTPCFlag) { + if(GetSigmaToVertex(track) > fMaxSigmaToVertexTPC) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a %lf sigmas to vertex TPC (max. requested: %lf)",GetSigmaToVertex(track),fMaxSigmaToVertexTPC); + return kFALSE; + } + } + if(fMaxDCAXYFlag) { + if(TMath::Abs(dca[0]) > fMaxDCAXY) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a value of dca(xy) of %lf (max. requested: %lf)",TMath::Abs(dca[0]),fMaxDCAXY); + return kFALSE; + } + } + if(fMaxDCAXYTPCFlag) { + if(TMath::Abs(dca[0]) > fMaxDCAXYTPC) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a value of dca(xy) (TPC) of %lf (max. requested: %lf)",TMath::Abs(dca[0]),fMaxDCAXYTPC); + return kFALSE; + } + } + if(fMaxDCAZFlag) { + if(TMath::Abs(dca[1]) > fMaxDCAZ) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a value of dca(z) of %lf (max. requested: %lf)",TMath::Abs(dca[1]),fMaxDCAZ); + return kFALSE; + } + } + if(fMaxDCAZTPCFlag) { + if(TMath::Abs(dca[1]) > fMaxDCAZTPC) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a value of dca(z) (TPC) of %lf (max. requested: %lf)",TMath::Abs(dca[1]),fMaxDCAZTPC); + return kFALSE; + } + } + if(fMaxDCA3DFlag) { + if(TMath::Abs(dca3D) > fMaxDCA3D) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a value of dca(3D) of %lf (max. requested: %lf)",TMath::Abs(dca3D),fMaxDCA3D); + return kFALSE; + } + } + if(fMaxDCA3DTPCFlag) { + if(TMath::Abs(dca3D) > fMaxDCA3DTPC) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a value of dca(3D) (TPC) of %lf (max. requested: %lf)",TMath::Abs(dca3D),fMaxDCA3DTPC); + return kFALSE; + } + } + if(fMaxConstrainChi2Flag) { + if(track->GetConstrainedChi2() > 0) + if(TMath::Log(track->GetConstrainedChi2()) > fMaxConstrainChi2) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has a value of the constrained chi2 to the vertex of %lf (max. requested: %lf)",TMath::Log(track->GetConstrainedChi2()),fMaxConstrainChi2); + return kFALSE; + } + } + if(fMinTPCdEdxPointsFlag) { + if(track->GetTPCsignalN() < fMinTPCdEdxPoints) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has %d TPC points for the calculation of the energy loss (min. requested: %d)",track->GetTPCsignalN(),fMinTPCdEdxPoints); + return kFALSE; + } + } + if(fITSRefitFlag) { + if ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has no ITS refit flag"); + return kFALSE; + } + } + if(fTPCRefitFlag) { + if ((track->GetStatus() & AliESDtrack::kTPCrefit) == 0) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has no TPC refit flag"); + return kFALSE; + } + } + if(fESDpidFlag) { + if ((track->GetStatus() & AliESDtrack::kESDpid) == 0) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has no ESD pid flag"); + return kFALSE; + } + } + if(fTPCpidFlag) { + if ((track->GetStatus() & AliESDtrack::kTPCpid) == 0) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has no TPC pid flag"); + return kFALSE; + } + } + if(fTOFpidFlag) { + if ((track->GetStatus() & AliESDtrack::kTOFpid) == 0) { + if(fDebugMode) + Printf("IsPrimary: Track rejected because it has no TOF pid flag"); + return kFALSE; + } + } + + return kTRUE; +} + //____________________________________________________________________// Float_t AliProtonAnalysisBase::GetSigmaToVertex(AliESDtrack* esdTrack) const { // Calculates the number of sigma to the vertex. - Float_t b[2]; Float_t bRes[2]; Float_t bCov[3]; @@ -560,6 +836,7 @@ const AliESDVertex* AliProtonAnalysisBase::GetVertex(AliESDEvent* esd, ((TH1F *)(fListVertexQA->At(0)))->Fill(vertex->GetXv()); ((TH1F *)(fListVertexQA->At(2)))->Fill(vertex->GetYv()); ((TH1F *)(fListVertexQA->At(4)))->Fill(vertex->GetZv()); + //check position if(TMath::Abs(vertex->GetXv()) > gVxMax) { if(fDebugMode) @@ -579,6 +856,17 @@ const AliESDVertex* AliProtonAnalysisBase::GetVertex(AliESDEvent* esd, ((TH1F *)(fListVertexQA->At(1)))->Fill(vertex->GetXv()); ((TH1F *)(fListVertexQA->At(3)))->Fill(vertex->GetYv()); ((TH1F *)(fListVertexQA->At(5)))->Fill(vertex->GetZv()); + ((TH1F *)(fListVertexQA->At(6)))->Fill(vertex->GetNContributors()); + + //check number of contributors + if(fMinNumOfContributors > 0) { + if(fMinNumOfContributors > vertex->GetNContributors()) { + if(fDebugMode) + Printf("GetVertex: Event rejected because it has %d number of contributors (requested minimum: %d)",vertex->GetNContributors(),fMinNumOfContributors); + + return 0; + } + } return vertex; } @@ -852,22 +1140,22 @@ Bool_t AliProtonAnalysisBase::IsProton(AliESDtrack *track) { else if(fProtonPIDMode == kSigma1) { Double_t fAlephParameters[5]; if(fAnalysisMC) { - fAlephParameters[0] = 4.23232575531564326e+00; - fAlephParameters[1] = 8.68482806165147636e+00; - fAlephParameters[2] = 1.34000000000000005e-05; - fAlephParameters[3] = 2.30445734159456084e+00; - fAlephParameters[4] = 2.25624744086878559e+00; + fAlephParameters[0] = 2.15898e+00/50.; + fAlephParameters[1] = 1.75295e+01; + fAlephParameters[2] = 3.40030e-09; + fAlephParameters[3] = 1.96178e+00; + fAlephParameters[4] = 3.91720e+00; } else { - fAlephParameters[0] = 50*0.76176e-1; - fAlephParameters[1] = 10.632; - fAlephParameters[2] = 0.13279e-4; - fAlephParameters[3] = 1.8631; - fAlephParameters[4] = 1.9479; + fAlephParameters[0] = 0.0283086; + fAlephParameters[1] = 2.63394e+01; + fAlephParameters[2] = 5.04114e-11; + fAlephParameters[3] = 2.12543e+00; + fAlephParameters[4] = 4.88663e+00; } AliESDpid *fESDpid = new AliESDpid(); - fESDpid->GetTPCResponse().SetBetheBlochParameters(fAlephParameters[0]/50.,fAlephParameters[1],fAlephParameters[2],fAlephParameters[3],fAlephParameters[4]); + fESDpid->GetTPCResponse().SetBetheBlochParameters(fAlephParameters[0],fAlephParameters[1],fAlephParameters[2],fAlephParameters[3],fAlephParameters[4]); Double_t nsigma = TMath::Abs(fESDpid->NumberOfSigmasTPC(track,AliPID::kProton)); if(nsigma <= fNSigma) diff --git a/PWG2/SPECTRA/AliProtonAnalysisBase.h b/PWG2/SPECTRA/AliProtonAnalysisBase.h index 4afd998d07b..e0608cfd620 100644 --- a/PWG2/SPECTRA/AliProtonAnalysisBase.h +++ b/PWG2/SPECTRA/AliProtonAnalysisBase.h @@ -59,6 +59,9 @@ class AliProtonAnalysisBase : public TObject { Double_t GetVxMax() const {return fVxMax;} Double_t GetVyMax() const {return fVyMax;} Double_t GetVzMax() const {return fVzMax;} + void SetMinNumOfContributors(Int_t nContributors) { + fMinNumOfContributors = nContributors;} + Int_t GetMinNumOfContributors() {return fMinNumOfContributors;} void SetPhaseSpace(Int_t nBinsX, Double_t gXmin, Double_t gXmax, Int_t nBinsY, Double_t gYmin, Double_t gYmax) { @@ -73,6 +76,8 @@ class AliProtonAnalysisBase : public TObject { Double_t GetMaxY() const {return fMaxY;} //Trigger + Bool_t IsOnlineTriggerUsed() {return kUseOnlineTrigger;} + void UseOnlineTrigger() {kUseOnlineTrigger = kTRUE;} Bool_t IsEventTriggered(const AliESDEvent *esd, TriggerMode trigger = kMB2); void OfflineTriggerInit() { @@ -84,6 +89,9 @@ class AliProtonAnalysisBase : public TObject { Bool_t IsOfflineTriggerUsed() {return kUseOfflineTrigger;} AliPhysicsSelection *GetPhysicsSelectionObject() {return fPhysicsSelection;} + Bool_t IsPrimary(AliESDEvent *esd, + const AliESDVertex *vertex, + AliESDtrack *track); Bool_t IsAccepted(AliESDEvent *esd, const AliESDVertex *vertex, AliESDtrack *track); @@ -269,6 +277,7 @@ class AliProtonAnalysisBase : public TObject { TString fProtonAnalysisLevel;//"ESD", "AOD" or "MC" Bool_t fAnalysisMC; //kTRUE if MC analysis while reading the ESDs TriggerMode fTriggerMode; //Trigger mode + Bool_t kUseOnlineTrigger; //use the online trigger or not Bool_t kUseOfflineTrigger; //use the offline trigger or not AliPhysicsSelection *fPhysicsSelection; //Trigger selection: offline AnalysisMode fProtonAnalysisMode; //Analysis mode: TPC-Hybrid-Global @@ -276,6 +285,7 @@ class AliProtonAnalysisBase : public TObject { Bool_t fAnalysisEtaMode; //run the analysis in eta or y Double_t fVxMax, fVyMax, fVzMax; //vertex diamond constrain + Int_t fMinNumOfContributors;//min number of contributors Int_t fNBinsX; //number of bins in y or eta Double_t fMinX, fMaxX; //min & max value of y or eta diff --git a/PWG2/SPECTRA/macros/configProtonAnalysis.C b/PWG2/SPECTRA/macros/configProtonAnalysis.C index 07f2ff803f6..09bd4c5a56b 100644 --- a/PWG2/SPECTRA/macros/configProtonAnalysis.C +++ b/PWG2/SPECTRA/macros/configProtonAnalysis.C @@ -4,7 +4,7 @@ AliProtonAnalysis *GetProtonAnalysisObject(const char* analysisLevel = "ESD", const char* esdAnalysisType = "Hybrid", const char* pidMode = "Bayesian") { // UInt_t runNumberForOfflineTrigger = -1) { - gROOT->LoadMacro("$ALICE_ROOT/PWG2/SPECTRA/macros/configProtonAnalysisBaseObject.C"); + gROOT->LoadMacro("configProtonAnalysisBaseObject.C"); //Function to setup the AliProtonAnalysis object and return it AliProtonAnalysisBase *baseAnalysis = GetProtonAnalysisBaseObject(analysisLevel,kAnalyzeMC,esdAnalysisType,pidMode); diff --git a/PWG2/SPECTRA/macros/configProtonAnalysisBaseObject.C b/PWG2/SPECTRA/macros/configProtonAnalysisBaseObject.C index fe1952397e1..949cb4086a8 100644 --- a/PWG2/SPECTRA/macros/configProtonAnalysisBaseObject.C +++ b/PWG2/SPECTRA/macros/configProtonAnalysisBaseObject.C @@ -13,12 +13,12 @@ AliProtonAnalysisBase *GetProtonAnalysisBaseObject(const char* analysisLevel = " baseAnalysis->OfflineTriggerInit(); baseAnalysis->SetMinTPCClusters(80); - baseAnalysis->SetMaxChi2PerTPCCluster(2.5); - baseAnalysis->SetMaxCov11(2.5); - baseAnalysis->SetMaxCov22(1.0); - baseAnalysis->SetMaxCov33(2.5); - baseAnalysis->SetMaxCov44(2.5); - baseAnalysis->SetMaxCov55(2.5); + baseAnalysis->SetMaxChi2PerTPCCluster(3.5); + baseAnalysis->SetMaxCov11(2.0); + baseAnalysis->SetMaxCov22(2.0); + baseAnalysis->SetMaxCov33(0.5); + baseAnalysis->SetMaxCov44(0.5); + baseAnalysis->SetMaxCov55(2.0); baseAnalysis->SetMinTPCdEdxPoints(80); switch(esdAnalysisType) { case "TPC": @@ -31,19 +31,19 @@ AliProtonAnalysisBase *GetProtonAnalysisBaseObject(const char* analysisLevel = " break; case "Hybrid": baseAnalysis->SetAnalysisMode(AliProtonAnalysisBase::kHybrid); - baseAnalysis->SetPhaseSpace(10, -0.5, 0.5, 16, 0.5, 0.9); + baseAnalysis->SetPhaseSpace(9, -0.9, 0.9, 5, 0.4, 0.9); //baseAnalysis->SetPhaseSpace(18, -0.9, 0.9, 32, 0.5, 1.3); baseAnalysis->SetTPCpid(); - baseAnalysis->SetMaxSigmaToVertex(2.0); - /*baseAnalysis->SetMaxDCAXY(1.5); - baseAnalysis->SetMaxDCAZ(1.5);*/ - baseAnalysis->SetPointOnITSLayer6(); - baseAnalysis->SetPointOnITSLayer5(); + baseAnalysis->SetMaxSigmaToVertex(3.0); + /*baseAnalysis->SetMaxDCAXY(3.0); + baseAnalysis->SetMaxDCAZ(3.0);*/ + //baseAnalysis->SetPointOnITSLayer6(); + //baseAnalysis->SetPointOnITSLayer5(); //baseAnalysis->SetPointOnITSLayer4(); //baseAnalysis->SetPointOnITSLayer3(); - baseAnalysis->SetPointOnITSLayer2(); - baseAnalysis->SetPointOnITSLayer1(); - baseAnalysis->SetMinITSClusters(4); + //baseAnalysis->SetPointOnITSLayer2(); + //baseAnalysis->SetPointOnITSLayer1(); + baseAnalysis->SetMinITSClusters(2); break; case "Global": baseAnalysis->SetAnalysisMode(AliProtonAnalysisBase::kGlobal); @@ -66,7 +66,8 @@ AliProtonAnalysisBase *GetProtonAnalysisBaseObject(const char* analysisLevel = " default: break; } - baseAnalysis->SetAcceptedVertexDiamond(5.,5.,25.); + baseAnalysis->SetAcceptedVertexDiamond(2.,2.,15.); + baseAnalysis->SetMinNumOfContributors(3); baseAnalysis->SetEtaMode(); switch(pidMode) { case "Bayesian": @@ -93,7 +94,7 @@ AliProtonAnalysisBase *GetProtonAnalysisBaseObject(const char* analysisLevel = " break; case "Sigma1": baseAnalysis->SetPIDMode(AliProtonAnalysisBase::kSigma1); - baseAnalysis->SetNSigma(3); + baseAnalysis->SetNSigma(4); baseAnalysis->SetdEdxBandInfo("$ALICE_ROOT/PWG2/data/protonsdEdxInfo.dat"); break; case "Sigma2": diff --git a/PWG2/SPECTRA/macros/drawProtonResults.C b/PWG2/SPECTRA/macros/drawProtonResults.C index aecebb8500e..7971df375bb 100644 --- a/PWG2/SPECTRA/macros/drawProtonResults.C +++ b/PWG2/SPECTRA/macros/drawProtonResults.C @@ -18,20 +18,6 @@ void drawResults(const char* analysisOutput) { gSystem->Load("libCORRFW.so"); gSystem->Load("libPWG2spectra.so"); - //Open the input file and get the objects - /*TFile *f = TFile::Open(analysisOutput); - TList *analysisList = dynamic_cast(f->Get("outputList")); - TH2D *gHistYPtProtons = dynamic_cast(analysisList->At(0)); - TH2D *gHistYPtAntiProtons = dynamic_cast(analysisList->At(1)); - AliCFContainer *cfProtons = dynamic_cast(analysisList->At(3)); - AliCFContainer *cfAntiProtons = dynamic_cast(analysisList->At(4)); - TH1F *gHistEventStats = dynamic_cast(analysisList->At(5)); - gHistEventStats->SetStats(kFALSE); - if(gHistEventStats->GetBinContent(1) != 0) { - gHistEventStats->GetYaxis()->SetTitle("N_{events} [%]"); - gHistEventStats->Scale(100./gHistEventStats->GetBinContent(1)); - }*/ - //Create the AliProtonAnalysis object AliProtonAnalysis *analysis = new AliProtonAnalysis(); analysis->ReadFromFile(analysisOutput); @@ -46,7 +32,7 @@ void drawResults(const char* analysisOutput) { TH1D *gHistPtRatio = dynamic_cast(analysis->GetPtRatioHistogram()); //==================================================================// - TH2F *hEmptyRatio = new TH2F("hEmptyRatio",";;#bar{p}/p",100,-0.7,1.1,100,0.1,1.1); + TH2F *hEmptyRatio = new TH2F("hEmptyRatio",";;#bar{p}/p",100,-1.1,1.1,100,0.1,1.1); hEmptyRatio->SetStats(kFALSE); hEmptyRatio->GetXaxis()->SetNdivisions(10); hEmptyRatio->GetYaxis()->SetNdivisions(10); @@ -81,7 +67,7 @@ void drawResults(const char* analysisOutput) { TCanvas *cRatio = new TCanvas("cRatio","Ratio",300,0,600,400); cRatio->SetFillColor(10); cRatio->SetHighLightColor(10); cRatio->Divide(2,1); cRatio->cd(1); hEmptyRatio->GetXaxis()->SetTitle("eta"); - hEmptyRatio->GetXaxis()->SetRangeUser(-0.7,0.7); + hEmptyRatio->GetXaxis()->SetRangeUser(-1.0,1.0); hEmptyRatio->DrawCopy(); gHistYRatio->Draw("ESAME"); gHistYRatio->Fit("fFitFunction","N"); latex->DrawLatex(-0.1,0.45,"ALICE PRELIMINARY"); @@ -94,6 +80,13 @@ void drawResults(const char* analysisOutput) { Printf("=========================================="); + for(Int_t iBin = 1; iBin <= gHistYRatio->GetNbinsX(); iBin++) + Printf("Eta: %lf - Ratio: %lf - Error: %lf", + gHistYRatio->GetBinCenter(iBin), + gHistYRatio->GetBinContent(iBin), + gHistYRatio->GetBinError(iBin)); + Printf("=========================================="); + Printf("Fit result: %lf - %lf",fFitFunction->GetParameter(0),fFitFunction->GetParError(0)); analysis->PrintMean(gHistYRatio,0.5); Printf("=========================================="); @@ -194,13 +187,27 @@ void drawQAPlots(const char* analysisOutput) { TH2D *gHistProtonsPhiTPCNPoints = dynamic_castgHistProtonsPtPhiTPCNPoints->Project3D("zy"); gHistProtonsPhiTPCNPoints->SetStats(kFALSE); + //2D eta-phi- accepted protons & antiprotons + TH2F *gHistEtaPhiProtons = dynamic_cast(fQA2DList->At(10)); + gHistEtaPhiProtons->SetStats(kFALSE); + TH2F *gHistEtaPhiAntiProtons = dynamic_cast(fQA2DList->At(11)); + gHistEtaPhiAntiProtons->SetStats(kFALSE); + //__________________________________________________// TCanvas *cdEdx = new TCanvas("cdEdx","dE/dx (TPC)",0,0,700,400); cdEdx->SetFillColor(10); cdEdx->SetHighLightColor(10); cdEdx->Divide(2,1); cdEdx->cd(1)->SetLogx(); gHistdEdxP->Draw("col"); cdEdx->cd(2)->SetLogx(); gHistProtonsdEdxP->Draw("col"); - TCanvas *cEtaPhiNPointsdEdx = new TCanvas("cEtaPhiNPointsdEdx", + TCanvas *cEtaPhi = new TCanvas("cEtaPhi", + "eta-phi", + 0,0,700,400); + cEtaPhi->SetFillColor(10); + cEtaPhi->SetHighLightColor(10); cEtaPhi->Divide(2,1); + cEtaPhi->cd(1); gHistEtaPhiProtons->Draw("colz"); + cEtaPhi->cd(2); gHistEtaPhiAntiProtons->Draw("colz"); + + /*TCanvas *cEtaPhiNPointsdEdx = new TCanvas("cEtaPhiNPointsdEdx", "eta-phi-NPoints(dE/dx)", 0,0,900,600); cEtaPhiNPointsdEdx->SetFillColor(10); @@ -246,7 +253,7 @@ void drawQAPlots(const char* analysisOutput) { cPtPhiNPoints->cd(3); gHistPhiTPCNPoints->Draw("col"); cPtPhiNPoints->cd(4); gHistProtonsPtPhi->Draw("col"); cPtPhiNPoints->cd(5); gHistProtonsPtTPCNPoints->Draw("col"); - cPtPhiNPoints->cd(6); gHistProtonsPhiTPCNPoints->Draw("col"); + cPtPhiNPoints->cd(6); gHistProtonsPhiTPCNPoints->Draw("col");*/ //Accepted protons TList *fQAProtonsAcceptedList = dynamic_cast(gListGlobalQA->At(1)); @@ -530,6 +537,8 @@ void drawQAPlots(const char* analysisOutput) { TH1F *gHistVz = dynamic_cast(gListVertexQA->At(4)); TH1F *gHistVzAccepted = dynamic_cast(gListVertexQA->At(5)); gHistVzAccepted->SetFillColor(10); + TH1F *gHistNumberOfContributors = dynamic_cast(gListVertexQA->At(6)); + gHistNumberOfContributors->SetFillColor(10); TCanvas *cVertex = new TCanvas("cVertex","Vertex QA",0,0,900,400); cVertex->SetFillColor(10); cVertex->SetHighLightColor(10); @@ -537,4 +546,8 @@ void drawQAPlots(const char* analysisOutput) { cVertex->cd(1)->SetLogy(); gHistVx->Draw(); gHistVxAccepted->Draw("same"); cVertex->cd(2)->SetLogy(); gHistVy->Draw(); gHistVyAccepted->Draw("same"); cVertex->cd(3)->SetLogy(); gHistVz->Draw(); gHistVzAccepted->Draw("same"); + + TCanvas *cVertexNContributors = new TCanvas("cVertexNContributors", + "Vertex QA",0,0,400,400); + gHistNumberOfContributors->Draw(); } diff --git a/PWG2/SPECTRA/macros/runProtonAnalysis.C b/PWG2/SPECTRA/macros/runProtonAnalysis.C index ca0b862d968..11334b13d25 100644 --- a/PWG2/SPECTRA/macros/runProtonAnalysis.C +++ b/PWG2/SPECTRA/macros/runProtonAnalysis.C @@ -1,6 +1,6 @@ void runProtonAnalysis(Bool_t kAnalyzeMC = kTRUE, const char* esdAnalysisType = "Hybrid", - const char* pidMode = "Bayesian") { + const char* pidMode = "Sigma1") { //Int_t runNumberForOfflineTtrigger = -1) { //Macro to run the proton analysis tested for local, proof & GRID. //Local: Takes six arguments, the analysis mode, a boolean to define the ESD @@ -32,15 +32,15 @@ void runProtonAnalysis(Bool_t kAnalyzeMC = kTRUE, TStopwatch timer; timer.Start(); - runLocal("ESD", + /*runLocal("ESD", kAnalyzeMC, esdAnalysisType, pidMode, //runNumberForOfflineTtrigger, - "/home/pchrist/ALICE/Baryons/Data/104070"); + "/home/pchrist/ALICE/Baryons/Data/104070");*/ //runInteractive("ESD", kAnalyzeMC, esdAnalysisType, pidMode, "tag.xml"); //runBatch("ESD", kAnalyzeMC, esdAnalysisType, pidMode, "wn.xml"); - //runProof("ESD", kAnalyzeMC, esdAnalysisType, pidMode, - //500000,0,"/COMMON/COMMON/LHC09d1_0.9TeV_0.5T#esdTree"); + runProof("ESD", kAnalyzeMC, esdAnalysisType, pidMode, + 250000,0,"/COMMON/COMMON/LHC09d10_run104792-3#esdTree"); timer.Stop(); timer.Print(); diff --git a/PWG2/SPECTRA/macros/runProtonAnalysisQA.C b/PWG2/SPECTRA/macros/runProtonAnalysisQA.C index 51986fc8e5a..e1e4fc4c8a0 100644 --- a/PWG2/SPECTRA/macros/runProtonAnalysisQA.C +++ b/PWG2/SPECTRA/macros/runProtonAnalysisQA.C @@ -23,7 +23,7 @@ void runProtonAnalysisQA(const char* esdAnalysisType = "Hybrid", timer.Start(); //runLocal("ESD",esdAnalysisType,pidMode,"/home/pchrist/ALICE/Baryons/QA/Local"); - runProof("ESD",esdAnalysisType,pidMode,100000,"/COMMON/COMMON/LHC09d10_run104799-801#esdTree"); + runProof("ESD",esdAnalysisType,pidMode,100000,"/COMMON/COMMON/LHC09d10_run104792-3#esdTree"); //runInteractive("ESD",esdAnalysisType,pidMode,"wn.xml"); //runBatch("ESD",esdAnalysisType,pidMode,"wn.xml");