#include "AliMCEvent.h"
#include "AliStack.h"
#include "AliESDVertex.h"
+#include "AliPhysicsSelection.h"
#include "AliProtonQAAnalysis.h"
#include "AliProtonAnalysisBase.h"
Printf("ERROR: Could not retrieve the stack");
return;
}
-
- if(dynamic_cast<AliProtonAnalysisBase*>(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->IsEventTriggered(fESD,dynamic_cast<AliProtonAnalysisBase*>(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetTriggerMode())) {
- fProtonQAAnalysis->RunVertexQA(header,
- fESD);
- const AliESDVertex *vertex = dynamic_cast<AliProtonAnalysisBase*>(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetVertex(fESD,dynamic_cast<AliProtonAnalysisBase*>(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetAnalysisMode(),dynamic_cast<AliProtonAnalysisBase*>(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetVxMax(),dynamic_cast<AliProtonAnalysisBase*>(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetVyMax(),dynamic_cast<AliProtonAnalysisBase*>(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<AliProtonAnalysisBase*>(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->IsEventTriggered(fESD,dynamic_cast<AliProtonAnalysisBase*>(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetTriggerMode())) {
+ //offline trigger
+ if(dynamic_cast<AliProtonAnalysisBase*>(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->IsOfflineTriggerUsed()) {
+ AliPhysicsSelection *gPhysicselection = dynamic_cast<AliPhysicsSelection *>(dynamic_cast<AliProtonAnalysisBase*>(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetPhysicsSelectionObject());
+ if(gPhysicselection->IsCollisionCandidate(fESD)) {
+ fProtonQAAnalysis->RunVertexQA(header,
+ fESD);
+ const AliESDVertex *vertex = dynamic_cast<AliProtonAnalysisBase*>(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetVertex(fESD,dynamic_cast<AliProtonAnalysisBase*>(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetAnalysisMode(),dynamic_cast<AliProtonAnalysisBase*>(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetVxMax(),dynamic_cast<AliProtonAnalysisBase*>(fProtonQAAnalysis->GetProtonAnalysisBaseObject())->GetVyMax(),dynamic_cast<AliProtonAnalysisBase*>(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);
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");
kNSteps,2,iBin);
fAntiProtonContainer->SetBinLimits(0,binLimY); //rapidity or eta
fAntiProtonContainer->SetBinLimits(1,binLimPt); //pT
+
+ //Initialize the QA
+ if(!fInitQAFlag) InitQA();
}
//____________________________________________________________________//
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");
kNSteps,2,iBin);
fAntiProtonContainer->SetBinLimits(0,gY); //rapidity or eta
fAntiProtonContainer->SetBinLimits(1,gPt); //pT
+
+ //Initialize the QA
+ if(!fInitQAFlag) InitQA();
}
//____________________________________________________________________//
Int_t nbinsPt,
Float_t fLowPt, Float_t fHighPt) {
//Initializes the histograms
- if(!fInitQAFlag) InitQA();
fNBinsY = nbinsY;
fMinY = fLowY;
fMaxY = fHighY;
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];
kNSteps,2,iBin);
fAntiProtonContainer->SetBinLimits(0,gY); //rapidity
fAntiProtonContainer->SetBinLimits(1,gPt); //pT
+
+ //Initialize the QA
+ if(!fInitQAFlag) InitQA();
}
//____________________________________________________________________//
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();
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();
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();
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();
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))
//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);
//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);
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);
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");
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,
//____________________________________________________________________//
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),
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",
100,-25.,25.);
fListVertexQA->Add(gHistVzAccepted);
+ TH1F *gHistNumberOfContributors = new TH1F("gHistNumberOfContributors",
+ "Number of contributors;N_{contr.};Entries",
+ 100,0.,100.);
+ fListVertexQA->Add(gHistNumberOfContributors);
+
}
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)
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];
((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)
((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;
}
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)
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) {
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() {
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);
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
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
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);
baseAnalysis->OfflineTriggerInit();\r
\r
baseAnalysis->SetMinTPCClusters(80);\r
- baseAnalysis->SetMaxChi2PerTPCCluster(2.5);\r
- baseAnalysis->SetMaxCov11(2.5);\r
- baseAnalysis->SetMaxCov22(1.0);\r
- baseAnalysis->SetMaxCov33(2.5);\r
- baseAnalysis->SetMaxCov44(2.5);\r
- baseAnalysis->SetMaxCov55(2.5);\r
+ baseAnalysis->SetMaxChi2PerTPCCluster(3.5);\r
+ baseAnalysis->SetMaxCov11(2.0);\r
+ baseAnalysis->SetMaxCov22(2.0);\r
+ baseAnalysis->SetMaxCov33(0.5);\r
+ baseAnalysis->SetMaxCov44(0.5);\r
+ baseAnalysis->SetMaxCov55(2.0);\r
baseAnalysis->SetMinTPCdEdxPoints(80);\r
switch(esdAnalysisType) {\r
case "TPC":\r
break;\r
case "Hybrid":\r
baseAnalysis->SetAnalysisMode(AliProtonAnalysisBase::kHybrid);\r
- baseAnalysis->SetPhaseSpace(10, -0.5, 0.5, 16, 0.5, 0.9);\r
+ baseAnalysis->SetPhaseSpace(9, -0.9, 0.9, 5, 0.4, 0.9);\r
//baseAnalysis->SetPhaseSpace(18, -0.9, 0.9, 32, 0.5, 1.3);\r
baseAnalysis->SetTPCpid();\r
- baseAnalysis->SetMaxSigmaToVertex(2.0);\r
- /*baseAnalysis->SetMaxDCAXY(1.5);\r
- baseAnalysis->SetMaxDCAZ(1.5);*/\r
- baseAnalysis->SetPointOnITSLayer6();\r
- baseAnalysis->SetPointOnITSLayer5();\r
+ baseAnalysis->SetMaxSigmaToVertex(3.0);\r
+ /*baseAnalysis->SetMaxDCAXY(3.0);\r
+ baseAnalysis->SetMaxDCAZ(3.0);*/\r
+ //baseAnalysis->SetPointOnITSLayer6();\r
+ //baseAnalysis->SetPointOnITSLayer5();\r
//baseAnalysis->SetPointOnITSLayer4();\r
//baseAnalysis->SetPointOnITSLayer3();\r
- baseAnalysis->SetPointOnITSLayer2();\r
- baseAnalysis->SetPointOnITSLayer1();\r
- baseAnalysis->SetMinITSClusters(4);\r
+ //baseAnalysis->SetPointOnITSLayer2();\r
+ //baseAnalysis->SetPointOnITSLayer1();\r
+ baseAnalysis->SetMinITSClusters(2);\r
break;\r
case "Global":\r
baseAnalysis->SetAnalysisMode(AliProtonAnalysisBase::kGlobal);\r
default:\r
break;\r
}\r
- baseAnalysis->SetAcceptedVertexDiamond(5.,5.,25.);\r
+ baseAnalysis->SetAcceptedVertexDiamond(2.,2.,15.);\r
+ baseAnalysis->SetMinNumOfContributors(3);\r
baseAnalysis->SetEtaMode();\r
switch(pidMode) {\r
case "Bayesian":\r
break;\r
case "Sigma1":\r
baseAnalysis->SetPIDMode(AliProtonAnalysisBase::kSigma1);\r
- baseAnalysis->SetNSigma(3);\r
+ baseAnalysis->SetNSigma(4);\r
baseAnalysis->SetdEdxBandInfo("$ALICE_ROOT/PWG2/data/protonsdEdxInfo.dat");\r
break;\r
case "Sigma2":\r
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<TList *>(f->Get("outputList"));
- TH2D *gHistYPtProtons = dynamic_cast<TH2D *>(analysisList->At(0));
- TH2D *gHistYPtAntiProtons = dynamic_cast<TH2D *>(analysisList->At(1));
- AliCFContainer *cfProtons = dynamic_cast<AliCFContainer *>(analysisList->At(3));
- AliCFContainer *cfAntiProtons = dynamic_cast<AliCFContainer *>(analysisList->At(4));
- TH1F *gHistEventStats = dynamic_cast<TH1F *>(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);
TH1D *gHistPtRatio = dynamic_cast<TH1D *>(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);
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");
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("==========================================");
TH2D *gHistProtonsPhiTPCNPoints = dynamic_cast<TH2D *>gHistProtonsPtPhiTPCNPoints->Project3D("zy");
gHistProtonsPhiTPCNPoints->SetStats(kFALSE);
+ //2D eta-phi- accepted protons & antiprotons
+ TH2F *gHistEtaPhiProtons = dynamic_cast<TH2F *>(fQA2DList->At(10));
+ gHistEtaPhiProtons->SetStats(kFALSE);
+ TH2F *gHistEtaPhiAntiProtons = dynamic_cast<TH2F *>(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);
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<TList *>(gListGlobalQA->At(1));
TH1F *gHistVz = dynamic_cast<TH1F *>(gListVertexQA->At(4));
TH1F *gHistVzAccepted = dynamic_cast<TH1F *>(gListVertexQA->At(5));
gHistVzAccepted->SetFillColor(10);
+ TH1F *gHistNumberOfContributors = dynamic_cast<TH1F *>(gListVertexQA->At(6));
+ gHistNumberOfContributors->SetFillColor(10);
TCanvas *cVertex = new TCanvas("cVertex","Vertex QA",0,0,900,400);
cVertex->SetFillColor(10); cVertex->SetHighLightColor(10);
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();
}
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
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();
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");
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff