fNBinsY(0), fMinY(0), fMaxY(0),
fNBinsPt(0), fMinPt(0), fMaxPt(0),
fProtonContainer(0), fAntiProtonContainer(0),
- fHistEvents(0), fHistYPtProtons(0), fHistYPtAntiProtons(0),
- fHistEventStats(0),
+ fHistEvents(0), fHistYPtProtons(0), fHistYPtAntiProtons(0),
+ fHistYPtProtonsCorrected(0), fHistYPtAntiProtonsCorrected(0),
+ fHistEventStats(0), fYRatioInPtBinsList(0),
fEffGridListProtons(0), fCorrectionListProtons2D(0),
fEfficiencyListProtons1D(0), fCorrectionListProtons1D(0),
fEffGridListAntiProtons(0), fCorrectionListAntiProtons2D(0),
fEfficiencyListAntiProtons1D(0), fCorrectionListAntiProtons1D(0),
fCorrectProtons(0), fCorrectAntiProtons(0),
+ fHistEfficiencyYPtProtons(0), fHistEfficiencyYPtAntiProtons(0),
+ fHistCorrectionForCrossSectionYPtProtons(0),
+ fHistCorrectionForCrossSectionYPtAntiProtons(0),
+ fHistCorrectionForCrossSectionFlag(kFALSE),
+ fHistYPtCorrectionForCutsProtons(0), fHistYPtCorrectionForCutsAntiProtons(0),
+ fCorrectForCutsFlag(kFALSE),
+ fHistYPtCorrectionForTrackingProtons(0),
+ fHistYPtCorrectionForTrackingAntiProtons(0),
+ fCorrectForTrackingFlag(kFALSE),
+ fHistYPtCorrectionForFeedDownProtons(0),
+ fHistYPtCorrectionForFeedDownAntiProtons(0),
+ fCorrectForFeedDownFlag(kFALSE),
+ fHistYPtCorrectionForSecondaries(0), fCorrectForSecondariesFlag(kFALSE),
fGlobalQAList(0), fQA2DList(0),
fQAProtonsAcceptedList(0), fQAProtonsRejectedList(0),
- fQAAntiProtonsAcceptedList(0), fQAAntiProtonsRejectedList(0),
- fInitQAFlag(kFALSE) {
+ fQAAntiProtonsAcceptedList(0), fQAAntiProtonsRejectedList(0) {
//Default constructor
}
fNBinsY(nbinsY), fMinY(fLowY), fMaxY(fHighY),
fNBinsPt(nbinsPt), fMinPt(fLowPt), fMaxPt(fHighPt),
fProtonContainer(0), fAntiProtonContainer(0),
- fHistEvents(0), fHistYPtProtons(0), fHistYPtAntiProtons(0), fHistEventStats(0),
+ fHistEvents(0), fHistYPtProtons(0), fHistYPtAntiProtons(0),
+ fHistYPtProtonsCorrected(0), fHistYPtAntiProtonsCorrected(0),
+ fHistEventStats(0), fYRatioInPtBinsList(0),
fEffGridListProtons(0), fCorrectionListProtons2D(0),
fEfficiencyListProtons1D(0), fCorrectionListProtons1D(0),
fEffGridListAntiProtons(0), fCorrectionListAntiProtons2D(0),
fEfficiencyListAntiProtons1D(0), fCorrectionListAntiProtons1D(0),
fCorrectProtons(0), fCorrectAntiProtons(0),
+ fHistEfficiencyYPtProtons(0), fHistEfficiencyYPtAntiProtons(0),
+ fHistCorrectionForCrossSectionYPtProtons(0),
+ fHistCorrectionForCrossSectionYPtAntiProtons(0),
+ fHistCorrectionForCrossSectionFlag(kFALSE),
+ fHistYPtCorrectionForCutsProtons(0), fHistYPtCorrectionForCutsAntiProtons(0),
+ fCorrectForCutsFlag(kFALSE),
+ fHistYPtCorrectionForTrackingProtons(0),
+ fHistYPtCorrectionForTrackingAntiProtons(0),
+ fCorrectForTrackingFlag(kFALSE),
+ fHistYPtCorrectionForFeedDownProtons(0),
+ fHistYPtCorrectionForFeedDownAntiProtons(0),
+ fCorrectForFeedDownFlag(kFALSE),
+ fHistYPtCorrectionForSecondaries(0), fCorrectForSecondariesFlag(kFALSE),
fGlobalQAList(0), fQA2DList(0),
fQAProtonsAcceptedList(0), fQAProtonsRejectedList(0),
- fQAAntiProtonsAcceptedList(0), fQAAntiProtonsRejectedList(0),
- fInitQAFlag(kFALSE) {
+ fQAAntiProtonsAcceptedList(0), fQAAntiProtonsRejectedList(0) {
//Default constructor
fHistEvents = new TH1I("fHistEvents","Analyzed events",2,0.5,2.5);
fHistEvents->GetXaxis()->SetBinLabel(1,"Analyzed events");
fNBinsPt,fMinPt,fMaxPt);
fHistYPtProtons->SetStats(kTRUE);
fHistYPtProtons->GetYaxis()->SetTitle("P_{T} [GeV/c]");
- if(fProtonAnalysisBase->GetEtaMode())
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
fHistYPtProtons->GetXaxis()->SetTitle("#eta");
else
fHistYPtProtons->GetXaxis()->SetTitle("y");
fNBinsPt,fMinPt,fMaxPt);
fHistYPtAntiProtons->SetStats(kTRUE);
fHistYPtAntiProtons->GetYaxis()->SetTitle("P_{T} [GeV/c]");
- if(fProtonAnalysisBase->GetEtaMode())
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
fHistYPtAntiProtons->GetXaxis()->SetTitle("#eta");
else
fHistYPtAntiProtons->GetXaxis()->SetTitle("y");
fHistYPtAntiProtons->GetXaxis()->SetTitleColor(1);
+ fHistYPtProtonsCorrected = new TH2D("fHistYPtProtonsCorrected","Protons",
+ fNBinsY,fMinY,fMaxY,
+ fNBinsPt,fMinPt,fMaxPt);
+ fHistYPtProtonsCorrected->SetStats(kTRUE);
+ fHistYPtProtonsCorrected->GetYaxis()->SetTitle("P_{T} [GeV/c]");
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
+ fHistYPtProtonsCorrected->GetXaxis()->SetTitle("#eta");
+ else
+ fHistYPtProtonsCorrected->GetXaxis()->SetTitle("y");
+ fHistYPtProtonsCorrected->GetXaxis()->SetTitleColor(1);
+
+ fHistYPtAntiProtonsCorrected = new TH2D("fHistYPtAntiProtonsCorrected",
+ "Antiprotons",
+ fNBinsY,fMinY,fMaxY,
+ fNBinsPt,fMinPt,fMaxPt);
+ fHistYPtAntiProtonsCorrected->SetStats(kTRUE);
+ fHistYPtAntiProtonsCorrected->GetYaxis()->SetTitle("P_{T} [GeV/c]");
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
+ fHistYPtAntiProtonsCorrected->GetXaxis()->SetTitle("#eta");
+ else
+ fHistYPtAntiProtonsCorrected->GetXaxis()->SetTitle("y");
+ fHistYPtAntiProtonsCorrected->GetXaxis()->SetTitleColor(1);
+
//setting up the containers
Int_t iBin[2];
iBin[0] = nbinsY;
fAntiProtonContainer->SetBinLimits(1,binLimPt); //pT
//Initialize the QA
- if(!fInitQAFlag) InitQA();
+ if(fProtonAnalysisBase && fProtonAnalysisBase->IsQARun()) InitQA();
}
//____________________________________________________________________//
fNBinsY(nbinsY), fMinY(gY[0]), fMaxY(gY[nbinsY]),
fNBinsPt(nbinsPt), fMinPt(gPt[0]), fMaxPt(gPt[nbinsPt]),
fProtonContainer(0), fAntiProtonContainer(0),
- fHistEvents(0), fHistYPtProtons(0), fHistYPtAntiProtons(0), fHistEventStats(0),
+ fHistEvents(0), fHistYPtProtons(0), fHistYPtAntiProtons(0),
+ fHistYPtProtonsCorrected(0), fHistYPtAntiProtonsCorrected(0),
+ fHistEventStats(0), fYRatioInPtBinsList(0),
fEffGridListProtons(0), fCorrectionListProtons2D(0),
fEfficiencyListProtons1D(0), fCorrectionListProtons1D(0),
fEffGridListAntiProtons(0), fCorrectionListAntiProtons2D(0),
fEfficiencyListAntiProtons1D(0), fCorrectionListAntiProtons1D(0),
fCorrectProtons(0), fCorrectAntiProtons(0),
+ fHistEfficiencyYPtProtons(0), fHistEfficiencyYPtAntiProtons(0),
+ fHistCorrectionForCrossSectionYPtProtons(0),
+ fHistCorrectionForCrossSectionYPtAntiProtons(0),
+ fHistCorrectionForCrossSectionFlag(kFALSE),
+ fHistYPtCorrectionForCutsProtons(0), fHistYPtCorrectionForCutsAntiProtons(0),
+ fCorrectForCutsFlag(kFALSE),
+ fHistYPtCorrectionForTrackingProtons(0),
+ fHistYPtCorrectionForTrackingAntiProtons(0),
+ fCorrectForTrackingFlag(kFALSE),
+ fHistYPtCorrectionForFeedDownProtons(0),
+ fHistYPtCorrectionForFeedDownAntiProtons(0),
+ fCorrectForFeedDownFlag(kFALSE),
+ fHistYPtCorrectionForSecondaries(0), fCorrectForSecondariesFlag(kFALSE),
fGlobalQAList(0), fQA2DList(0),
fQAProtonsAcceptedList(0), fQAProtonsRejectedList(0),
- fQAAntiProtonsAcceptedList(0), fQAAntiProtonsRejectedList(0),
- fInitQAFlag(kFALSE) {
+ fQAAntiProtonsAcceptedList(0), fQAAntiProtonsRejectedList(0) {
//Default constructor
fHistEvents = new TH1I("fHistEvents","Analyzed events",2,0.5,2.5);
fHistEvents->GetXaxis()->SetBinLabel(1,"Analyzed events");
fNBinsY,gY,fNBinsPt,gPt);
fHistYPtProtons->SetStats(kTRUE);
fHistYPtProtons->GetYaxis()->SetTitle("P_{T} [GeV/c]");
- if(fProtonAnalysisBase->GetEtaMode())
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
fHistYPtProtons->GetXaxis()->SetTitle("#eta");
else
fHistYPtProtons->GetXaxis()->SetTitle("y");
fNBinsY,gY,fNBinsPt,gPt);
fHistYPtAntiProtons->SetStats(kTRUE);
fHistYPtAntiProtons->GetYaxis()->SetTitle("P_{T} [GeV/c]");
- if(fProtonAnalysisBase->GetEtaMode())
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
fHistYPtAntiProtons->GetXaxis()->SetTitle("#eta");
else
fHistYPtAntiProtons->GetXaxis()->SetTitle("y");
fHistYPtAntiProtons->GetXaxis()->SetTitleColor(1);
+ fHistYPtProtonsCorrected = new TH2D("fHistYPtProtonsCorrected","Protons",
+ fNBinsY,fMinY,fMaxY,
+ fNBinsPt,fMinPt,fMaxPt);
+ fHistYPtProtonsCorrected->SetStats(kTRUE);
+ fHistYPtProtonsCorrected->GetYaxis()->SetTitle("P_{T} [GeV/c]");
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
+ fHistYPtProtonsCorrected->GetXaxis()->SetTitle("#eta");
+ else
+ fHistYPtProtonsCorrected->GetXaxis()->SetTitle("y");
+ fHistYPtProtonsCorrected->GetXaxis()->SetTitleColor(1);
+
+ fHistYPtAntiProtonsCorrected = new TH2D("fHistYPtAntiProtonsCorrected",
+ "Antiprotons",
+ fNBinsY,fMinY,fMaxY,
+ fNBinsPt,fMinPt,fMaxPt);
+ fHistYPtAntiProtonsCorrected->SetStats(kTRUE);
+ fHistYPtAntiProtonsCorrected->GetYaxis()->SetTitle("P_{T} [GeV/c]");
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
+ fHistYPtAntiProtonsCorrected->GetXaxis()->SetTitle("#eta");
+ else
+ fHistYPtAntiProtonsCorrected->GetXaxis()->SetTitle("y");
+ fHistYPtAntiProtonsCorrected->GetXaxis()->SetTitleColor(1);
+
//setting up the containers
Int_t iBin[2];
iBin[0] = nbinsY;
fAntiProtonContainer->SetBinLimits(1,gPt); //pT
//Initialize the QA
- if(!fInitQAFlag) InitQA();
+ if(fProtonAnalysisBase && fProtonAnalysisBase->IsQARun()) InitQA();
}
//____________________________________________________________________//
if(fHistEvents) delete fHistEvents;
if(fHistYPtProtons) delete fHistYPtProtons;
if(fHistYPtAntiProtons) delete fHistYPtAntiProtons;
+ if(fHistYPtProtonsCorrected) delete fHistYPtProtonsCorrected;
+ if(fHistYPtAntiProtonsCorrected) delete fHistYPtAntiProtonsCorrected;
if(fHistEventStats) delete fHistEventStats;
+ if(fYRatioInPtBinsList) delete fYRatioInPtBinsList;
+
if(fProtonContainer) delete fProtonContainer;
if(fAntiProtonContainer) delete fAntiProtonContainer;
if(fCorrectionListAntiProtons1D) delete fCorrectionListAntiProtons1D;
if(fCorrectProtons) delete fCorrectProtons;
if(fCorrectAntiProtons) delete fCorrectAntiProtons;
+ if(fHistEfficiencyYPtProtons) delete fHistEfficiencyYPtProtons;
+ if(fHistEfficiencyYPtAntiProtons) delete fHistEfficiencyYPtAntiProtons;
+ if(fHistCorrectionForCrossSectionYPtProtons) delete fHistCorrectionForCrossSectionYPtProtons;
+ if(fHistCorrectionForCrossSectionYPtAntiProtons) delete fHistCorrectionForCrossSectionYPtAntiProtons;
+ if(fHistYPtCorrectionForCutsProtons) delete fHistYPtCorrectionForCutsProtons;
+ if(fHistYPtCorrectionForCutsAntiProtons) delete fHistYPtCorrectionForCutsAntiProtons;
+ if(fHistYPtCorrectionForTrackingProtons) delete fHistYPtCorrectionForTrackingProtons;
+ if(fHistYPtCorrectionForTrackingAntiProtons) delete fHistYPtCorrectionForTrackingAntiProtons;
+ if(fHistYPtCorrectionForFeedDownProtons) delete fHistYPtCorrectionForFeedDownProtons;
+ if(fHistYPtCorrectionForFeedDownAntiProtons) delete fHistYPtCorrectionForFeedDownAntiProtons;
+ if(fHistYPtCorrectionForSecondaries) delete fHistYPtCorrectionForSecondaries;
//QA lists
if(fGlobalQAList) delete fGlobalQAList;
fNBinsPt,fMinPt,fMaxPt);
fHistYPtProtons->SetStats(kTRUE);
fHistYPtProtons->GetYaxis()->SetTitle("P_{T} [GeV/c]");
- if(fProtonAnalysisBase->GetEtaMode())
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
fHistYPtProtons->GetXaxis()->SetTitle("#eta");
else
fHistYPtProtons->GetXaxis()->SetTitle("y");
fNBinsPt,fMinPt,fMaxPt);
fHistYPtAntiProtons->SetStats(kTRUE);
fHistYPtAntiProtons->GetYaxis()->SetTitle("P_{T} [GeV/c]");
- if(fProtonAnalysisBase->GetEtaMode())
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
fHistYPtAntiProtons->GetXaxis()->SetTitle("#eta");
else
fHistYPtAntiProtons->GetXaxis()->SetTitle("y");
fHistYPtAntiProtons->GetXaxis()->SetTitleColor(1);
+ fHistYPtProtonsCorrected = new TH2D("fHistYPtProtonsCorrected","Protons",
+ fNBinsY,fMinY,fMaxY,
+ fNBinsPt,fMinPt,fMaxPt);
+ fHistYPtProtonsCorrected->SetStats(kTRUE);
+ fHistYPtProtonsCorrected->GetYaxis()->SetTitle("P_{T} [GeV/c]");
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
+ fHistYPtProtonsCorrected->GetXaxis()->SetTitle("#eta");
+ else
+ fHistYPtProtonsCorrected->GetXaxis()->SetTitle("y");
+ fHistYPtProtonsCorrected->GetXaxis()->SetTitleColor(1);
+
+ fHistYPtAntiProtonsCorrected = new TH2D("fHistYPtAntiProtonsCorrected",
+ "Antiprotons",
+ fNBinsY,fMinY,fMaxY,
+ fNBinsPt,fMinPt,fMaxPt);
+ fHistYPtAntiProtonsCorrected->SetStats(kTRUE);
+ fHistYPtAntiProtonsCorrected->GetYaxis()->SetTitle("P_{T} [GeV/c]");
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
+ fHistYPtAntiProtonsCorrected->GetXaxis()->SetTitle("#eta");
+ else
+ fHistYPtAntiProtonsCorrected->GetXaxis()->SetTitle("y");
+ fHistYPtAntiProtonsCorrected->GetXaxis()->SetTitleColor(1);
+
//setting up the containers
Int_t iBin[2];
iBin[0] = nbinsY;
fAntiProtonContainer->SetBinLimits(0,binLimY); //rapidity
fAntiProtonContainer->SetBinLimits(1,binLimPt); //pT
+ delete [] binLimY;
+ delete [] binLimPt;
+
//Initialize the QA
- if(!fInitQAFlag) InitQA();
+ if(fProtonAnalysisBase && fProtonAnalysisBase->IsQARun()) InitQA();
}
//____________________________________________________________________//
fNBinsY,gY,fNBinsPt,gPt);
fHistYPtProtons->SetStats(kTRUE);
fHistYPtProtons->GetYaxis()->SetTitle("P_{T} [GeV/c]");
- if(fProtonAnalysisBase->GetEtaMode())
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
fHistYPtProtons->GetXaxis()->SetTitle("#eta");
else
fHistYPtProtons->GetXaxis()->SetTitle("y");
fNBinsY,gY,fNBinsPt,gPt);
fHistYPtAntiProtons->SetStats(kTRUE);
fHistYPtAntiProtons->GetYaxis()->SetTitle("P_{T} [GeV/c]");
- if(fProtonAnalysisBase->GetEtaMode())
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
fHistYPtAntiProtons->GetXaxis()->SetTitle("#eta");
else
fHistYPtAntiProtons->GetXaxis()->SetTitle("y");
fHistYPtAntiProtons->GetXaxis()->SetTitleColor(1);
+ fHistYPtProtonsCorrected = new TH2D("fHistYPtProtonsCorrected","Protons",
+ fNBinsY,gY,fNBinsPt,gPt);
+ fHistYPtProtonsCorrected->SetStats(kTRUE);
+ fHistYPtProtonsCorrected->GetYaxis()->SetTitle("P_{T} [GeV/c]");
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
+ fHistYPtProtonsCorrected->GetXaxis()->SetTitle("#eta");
+ else
+ fHistYPtProtonsCorrected->GetXaxis()->SetTitle("y");
+ fHistYPtProtonsCorrected->GetXaxis()->SetTitleColor(1);
+
+ fHistYPtAntiProtonsCorrected = new TH2D("fHistYPtAntiProtonsCorrected",
+ "Antiprotons",
+ fNBinsY,gY,fNBinsPt,gPt);
+ fHistYPtAntiProtonsCorrected->SetStats(kTRUE);
+ fHistYPtAntiProtonsCorrected->GetYaxis()->SetTitle("P_{T} [GeV/c]");
+ if(fProtonAnalysisBase && fProtonAnalysisBase->GetEtaMode())
+ fHistYPtAntiProtonsCorrected->GetXaxis()->SetTitle("#eta");
+ else
+ fHistYPtAntiProtonsCorrected->GetXaxis()->SetTitle("y");
+ fHistYPtAntiProtonsCorrected->GetXaxis()->SetTitleColor(1);
+
//setting up the containers
Int_t iBin[2];
iBin[0] = nbinsY;
fAntiProtonContainer->SetBinLimits(1,gPt); //pT
//Initialize the QA
- if(!fInitQAFlag) InitQA();
+ if(fProtonAnalysisBase && fProtonAnalysisBase->IsQARun()) InitQA();
}
//____________________________________________________________________//
cout<<"Could not find the input file "<<filename<<endl;
status = kFALSE;
}
-
- TList *list = (TList *)file->Get("outputList");
- if(list) {
- cout<<"Retrieving objects from the list "<<list->GetName()<<"..."<<endl;
- fHistYPtProtons = (TH2D *)list->At(0);
- fHistYPtAntiProtons = (TH2D *)list->At(1);
- fHistEvents = (TH1I *)list->At(2);
- fProtonContainer = (AliCFContainer *)list->At(3);
- fAntiProtonContainer = (AliCFContainer *)list->At(4);
- fHistEventStats = (TH1F *)list->At(5);
- }
- else if(!list) {
- cout<<"Retrieving objects from the file... "<<endl;
- fHistYPtProtons = (TH2D *)file->Get("fHistYPtProtons");
- fHistYPtAntiProtons = (TH2D *)file->Get("fHistYPtAntiProtons");
- fHistEvents = (TH1I *)file->Get("fHistEvents");
- fProtonContainer = (AliCFContainer *)file->Get("containerProtons");
- fAntiProtonContainer = (AliCFContainer *)file->Get("containerAntiProtons");
- fHistEventStats = (TH1F *)file->Get("fHistEventStats");
+ else {
+ TList *list = (TList *)file->Get("outputList");
+ if(list) {
+ cout<<"Retrieving objects from the list "<<list->GetName()<<"..."<<endl;
+ fHistYPtProtons = (TH2D *)list->At(0);
+ fHistYPtAntiProtons = (TH2D *)list->At(1);
+ fHistEvents = (TH1I *)list->At(2);
+ fProtonContainer = (AliCFContainer *)list->At(3);
+ fAntiProtonContainer = (AliCFContainer *)list->At(4);
+ fHistEventStats = (TH1F *)list->At(5);
+ }
+ else if(!list) {
+ cout<<"Retrieving objects from the file... "<<endl;
+ fHistYPtProtons = (TH2D *)file->Get("fHistYPtProtons");
+ fHistYPtAntiProtons = (TH2D *)file->Get("fHistYPtAntiProtons");
+ fHistEvents = (TH1I *)file->Get("fHistEvents");
+ fProtonContainer = (AliCFContainer *)file->Get("containerProtons");
+ fAntiProtonContainer = (AliCFContainer *)file->Get("containerAntiProtons");
+ fHistEventStats = (TH1F *)file->Get("fHistEventStats");
+ }
+ if((!fHistYPtProtons)||(!fHistYPtAntiProtons)||(!fHistEvents)
+ ||(!fProtonContainer)||(!fAntiProtonContainer)||(!fHistEventStats)) {
+ cout<<"Input containers were not found!!!"<<endl;
+ status = kFALSE;
+ }
+ else {
+ //fHistYPtProtons = fProtonContainer->ShowProjection(0,1,0);
+ //fHistYPtAntiProtons = fAntiProtonContainer->ShowProjection(0,1,0);
+ fHistYPtProtons->Sumw2();
+ fHistYPtAntiProtons->Sumw2();
+ }
}
- if((!fHistYPtProtons)||(!fHistYPtAntiProtons)||(!fHistEvents)
- ||(!fProtonContainer)||(!fAntiProtonContainer)||(!fHistEventStats)) {
- cout<<"Input containers were not found!!!"<<endl;
- status = kFALSE;
+ return status;
+}
+
+//____________________________________________________________________//
+TList *AliProtonAnalysis::GetYRatioHistogramsInPtBins() {
+ //Returns a TList obkect with the eta (or y) dependent ratios for each
+ //pT bin taken from the 2D histograms (not from the containers)
+ fYRatioInPtBinsList = new TList();
+
+ //Protons
+ TH1D *gHistYProtons[100];
+ TString title;
+ for(Int_t iBin = 1; iBin <= fHistYPtProtons->GetNbinsY(); iBin++) {
+ title = "gHistYProtons_PtBin"; title += iBin;
+ gHistYProtons[iBin] = (TH1D *)fHistYPtProtons->ProjectionX(title.Data(),
+ iBin,
+ iBin,"b");
+ gHistYProtons[iBin]->Sumw2();
}
- else {
- //fHistYPtProtons = fProtonContainer->ShowProjection(0,1,0);
- //fHistYPtAntiProtons = fAntiProtonContainer->ShowProjection(0,1,0);
- fHistYPtProtons->Sumw2();
- fHistYPtAntiProtons->Sumw2();
+
+ //Antiprotons
+ TH1D *gHistYAntiProtons[100];
+ for(Int_t iBin = 1; iBin <= fHistYPtAntiProtons->GetNbinsY(); iBin++) {
+ title = "gHistYAntiProtons_PtBin"; title += iBin;
+ gHistYAntiProtons[iBin] = (TH1D *)fHistYPtAntiProtons->ProjectionX(title.Data(),
+ iBin,
+ iBin,"b");
+ gHistYAntiProtons[iBin]->Sumw2();
}
- return status;
+ Double_t pTmin = fHistYPtProtons->GetYaxis()->GetXmin();
+ Double_t pTStep = (fHistYPtProtons->GetYaxis()->GetXmax() - fHistYPtProtons->GetYaxis()->GetXmin())/fHistYPtProtons->GetNbinsY();
+ Double_t pTmax = pTmin + pTStep;
+ //Ratio
+ TH1D *gHistYRatio[100];
+ for(Int_t iBin = 1; iBin <= fHistYPtProtons->GetNbinsY(); iBin++) {
+ title = "gHistYRatio_PtBin"; title += iBin;
+ gHistYRatio[iBin] = new TH1D(title.Data(),"",
+ fHistYPtProtons->GetNbinsX(),
+ fHistYPtProtons->GetXaxis()->GetXmin(),
+ fHistYPtProtons->GetXaxis()->GetXmax());
+ title = "Pt: "; title += pTmin; title += " - "; title += pTmax;
+ gHistYRatio[iBin]->SetTitle(title.Data());
+ gHistYRatio[iBin]->GetYaxis()->SetTitle("#bar{p}/p");
+ gHistYRatio[iBin]->GetXaxis()->SetTitle(fHistYPtProtons->GetXaxis()->GetTitle());
+ gHistYRatio[iBin]->Divide(gHistYAntiProtons[iBin],
+ gHistYProtons[iBin],1.0,1.0,"b");
+ fYRatioInPtBinsList->Add(gHistYRatio[iBin]);
+ pTmin += pTStep;
+ pTmax += pTStep;
+ }
+
+ return fYRatioInPtBinsList;
}
//____________________________________________________________________//
//Get the corrected y histogram for protons
Int_t nAnalyzedEvents = GetNumberOfAnalyzedEvents();
- TH1D *fYProtons = fCorrectProtons->Project(0); //0: rapidity
+ TH1D *fYProtons = (TH1D *)fHistYPtProtonsCorrected->ProjectionX("fYProtons",1,fHistYPtProtons->GetYaxis()->GetNbins(),"e");
+ //TH1D *fYProtons = fCorrectProtons->Project(0); //0: rapidity
fYProtons->SetStats(kFALSE);
fYProtons->GetYaxis()->SetTitle("(1/N_{events})(dN/dy)");
TH1D *AliProtonAnalysis::GetAntiProtonCorrectedYHistogram() {
//Get the corrected y histogram for antiprotons
Int_t nAnalyzedEvents = GetNumberOfAnalyzedEvents();
-
- TH1D *fYAntiProtons = fCorrectAntiProtons->Project(0); //0: rapidity
+
+ TH1D *fYAntiProtons = (TH1D *)fHistYPtAntiProtonsCorrected->ProjectionX("fYAntiProtons",1,fHistYPtAntiProtons->GetYaxis()->GetNbins(),"e");
+ //TH1D *fYAntiProtons = fCorrectAntiProtons->Project(0); //0: rapidity
fYAntiProtons->SetStats(kFALSE);
fYAntiProtons->GetYaxis()->SetTitle("(1/N_{events})(dN/dy)");
//Get the corrected Pt histogram for protons
Int_t nAnalyzedEvents = GetNumberOfAnalyzedEvents();
- TH1D *fPtProtons = fCorrectProtons->Project(0); //0: rapidity
+ //TH1D *fPtProtons = (TH1D *)fHistYPtProtonsCorrected->ProjectionY("fPtProtons",2,fHistYPtProtons->GetXaxis()->GetNbins()-1,"e");
+ TH1D *fPtProtons = (TH1D *)fHistYPtProtonsCorrected->ProjectionY("fPtProtons",3,7,"e"); //3,7: |y| < 0.5
+ //TH1D *fPtProtons = fCorrectProtons->Project(0); //0: rapidity
fPtProtons->SetStats(kFALSE);
fPtProtons->GetYaxis()->SetTitle("(1/N_{events})(dN/dP_{T})");
//Get the corrected Pt histogram for antiprotons
Int_t nAnalyzedEvents = GetNumberOfAnalyzedEvents();
- TH1D *fPtAntiProtons = fCorrectAntiProtons->Project(0); //0: rapidity
+ //TH1D *fPtAntiProtons = (TH1D *)fHistYPtAntiProtonsCorrected->ProjectionY("fPtAntiProtons",2,fHistYPtAntiProtons->GetXaxis()->GetNbins()-1,"e");
+ TH1D *fPtAntiProtons = (TH1D *)fHistYPtAntiProtonsCorrected->ProjectionY("fPtAntiProtons",3,7,"e"); //3,7: |y| < 0.5
+//TH1D *fPtAntiProtons = fCorrectAntiProtons->Project(0); //0: rapidity
fPtAntiProtons->SetStats(kFALSE);
fPtAntiProtons->GetYaxis()->SetTitle("(1/N_{events})(dN/dP_{T})");
TH1D *fYAntiProtons = GetAntiProtonYHistogram();
TH1D *hRatioY = new TH1D("hRatioY","",fYProtons->GetNbinsX(),fYProtons->GetXaxis()->GetXmin(),fYProtons->GetXaxis()->GetXmax());
- hRatioY->Divide(fYAntiProtons,fYProtons,1.0,1.0);
+ hRatioY->Divide(fYAntiProtons,fYProtons,1.0,1.0,"e");
hRatioY->SetMarkerStyle(kFullCircle);
hRatioY->SetMarkerColor(4);
hRatioY->GetYaxis()->SetTitle("#bar{p}/p");
}
//____________________________________________________________________//
-TH1D *AliProtonAnalysis::GetYRatioCorrectedHistogram(TH2D *gCorrectionProtons,
- TH2D *gCorrectionAntiProtons) {
+TH1D *AliProtonAnalysis::GetYRatioCorrectedHistogram() {
+//TH2D *gCorrectionProtons,
+//TH2D *gCorrectionAntiProtons) {
//Returns the rapidity dependence of the ratio (corrected)
- fHistYPtProtons->Multiply(gCorrectionProtons);
- TH1D *fYProtons = GetProtonYHistogram();
- fHistYPtAntiProtons->Multiply(gCorrectionAntiProtons);
- TH1D *fYAntiProtons = GetAntiProtonYHistogram();
+ //fHistYPtProtons->Multiply(gCorrectionProtons);
+ TH1D *fYProtons = GetProtonCorrectedYHistogram();
+ //fHistYPtAntiProtons->Multiply(gCorrectionAntiProtons);
+ TH1D *fYAntiProtons = GetAntiProtonCorrectedYHistogram();
TH1D *hRatioY = new TH1D("hRatioY","",fYProtons->GetNbinsX(),fYProtons->GetXaxis()->GetXmin(),fYProtons->GetXaxis()->GetXmax());
- hRatioY->Divide(fYAntiProtons,fYProtons,1.0,1.0);
+ hRatioY->Divide(fYAntiProtons,fYProtons,1.0,1.0,"e");
hRatioY->SetMarkerStyle(kFullCircle);
hRatioY->SetMarkerColor(4);
hRatioY->GetYaxis()->SetTitle("#bar{p}/p");
TH1D *fPtAntiProtons = GetAntiProtonPtHistogram();
TH1D *hRatioPt = new TH1D("hRatioPt","",fPtProtons->GetNbinsX(),fPtProtons->GetXaxis()->GetXmin(),fPtProtons->GetXaxis()->GetXmax());
- hRatioPt->Divide(fPtAntiProtons,fPtProtons,1.0,1.0);
+ hRatioPt->Divide(fPtAntiProtons,fPtProtons,1.0,1.0,"e");
hRatioPt->SetMarkerStyle(kFullCircle);
hRatioPt->SetMarkerColor(4);
hRatioPt->GetYaxis()->SetTitle("#bar{p}/p");
}
//____________________________________________________________________//
-TH1D *AliProtonAnalysis::GetPtRatioCorrectedHistogram(TH2D *gCorrectionProtons,
- TH2D *gCorrectionAntiProtons) {
+TH1D *AliProtonAnalysis::GetPtRatioCorrectedHistogram() {
+ //TH2D *gCorrectionProtons,
+ //TH2D *gCorrectionAntiProtons) {
//Returns the Pt dependence of the ratio (corrected)
- fHistYPtProtons->Multiply(gCorrectionProtons);
- TH1D *fPtProtons = GetProtonPtHistogram();
- fHistYPtAntiProtons->Multiply(gCorrectionAntiProtons);
- TH1D *fPtAntiProtons = GetAntiProtonPtHistogram();
+ //fHistYPtProtons->Multiply(gCorrectionProtons);
+ TH1D *fPtProtons = GetProtonCorrectedPtHistogram();
+ //fHistYPtAntiProtons->Multiply(gCorrectionAntiProtons);
+ TH1D *fPtAntiProtons = GetAntiProtonCorrectedPtHistogram();
TH1D *hRatioPt = new TH1D("hRatioPt","",fPtProtons->GetNbinsX(),fPtProtons->GetXaxis()->GetXmin(),fPtProtons->GetXaxis()->GetXmax());
- hRatioPt->Divide(fPtAntiProtons,fPtProtons,1.0,1.0);
+ hRatioPt->Divide(fPtAntiProtons,fPtProtons,1.0,1.0,"e");
hRatioPt->SetMarkerStyle(kFullCircle);
hRatioPt->SetMarkerColor(4);
hRatioPt->GetYaxis()->SetTitle("#bar{p}/p");
hdiff->Add(fYProtons,fYAntiProtons,1.0,-1.0);
TH1D *hAsymmetryY = new TH1D("hAsymmetryY","",fYProtons->GetNbinsX(),fYProtons->GetXaxis()->GetXmin(),fYProtons->GetXaxis()->GetXmax());
- hAsymmetryY->Divide(hdiff,hsum,2.0,1.);
+ hAsymmetryY->Divide(hdiff,hsum,2.0,1.,"e");
hAsymmetryY->SetMarkerStyle(kFullCircle);
hAsymmetryY->SetMarkerColor(4);
hAsymmetryY->GetYaxis()->SetTitle("A_{p}");
hdiff->Add(fPtProtons,fPtAntiProtons,1.0,-1.0);
TH1D *hAsymmetryPt = new TH1D("hAsymmetryPt","",fPtProtons->GetNbinsX(),fPtProtons->GetXaxis()->GetXmin(),fPtProtons->GetXaxis()->GetXmax());
- hAsymmetryPt->Divide(hdiff,hsum,2.0,1.);
+ hAsymmetryPt->Divide(hdiff,hsum,2.0,1.,"e");
hAsymmetryPt->SetMarkerStyle(kFullCircle);
hAsymmetryPt->SetMarkerColor(4);
hAsymmetryPt->GetYaxis()->SetTitle("A_{p}");
Int_t nTracks = 0;
Int_t nIdentifiedProtons = 0, nIdentifiedAntiProtons = 0;
Int_t nSurvivedProtons = 0, nSurvivedAntiProtons = 0;
+
+ if(!fProtonAnalysisBase) return;
//=========================================//
//Aleph parametrization
fAlephParameters[3] = 2.12543e+00;
fAlephParameters[4] = 4.88663e+00;
}
- AliESDpid *fESDpid = new AliESDpid();
- AliTPCPIDResponse tpcResponse = fESDpid->GetTPCResponse();
- tpcResponse.SetBetheBlochParameters(fAlephParameters[0],fAlephParameters[1],fAlephParameters[2],fAlephParameters[3],fAlephParameters[4]);
+
+ AliTPCPIDResponse *tpcResponse = new AliTPCPIDResponse();
+ tpcResponse->SetBetheBlochParameters(fAlephParameters[0],fAlephParameters[1],fAlephParameters[2],fAlephParameters[3],fAlephParameters[4]);
//=========================================//
fHistEvents->Fill(1); //number of analyzed events
Double_t containerInput[2] ;
Double_t gPt = 0.0, gP = 0.0;
+ Float_t dcaXY = 0.0, dcaZ = 0.0;
+
nTracks = esd->GetNumberOfTracks();
for(Int_t iTracks = 0; iTracks < nTracks; iTracks++) {
AliESDtrack* track = esd->GetTrack(iTracks);
AliESDtrack trackTPC;
- //in case it's a TPC only track relate it to the proper vertex
- /*if(fProtonAnalysisBase->GetAnalysisMode()==AliProtonAnalysisBase::kTPC) {
- Float_t p[2],cov[3];
- track->GetImpactParametersTPC(p,cov);
- if (p[0]==0 && p[1]==0)
- track->RelateToVertexTPC(((AliESDEvent*)esd)->GetPrimaryVertexTPC(),esd->GetMagneticField(),kVeryBig);
- if (!track->FillTPCOnlyTrack(trackTPC)) {
- continue;
- }
- track = &trackTPC ;
- }*/
-
- Int_t fIdxInt[200];
- Int_t nClustersTPC = track->GetTPCclusters(fIdxInt);
+ Int_t nClustersTPC = track->GetTPCclusters(0x0);
Int_t npointsTPCdEdx = track->GetTPCsignalN();
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((fProtonAnalysisBase->GetAnalysisMode()==AliProtonAnalysisBase::kTPC)||(fProtonAnalysisBase->GetAnalysisMode()==AliProtonAnalysisBase::kHybrid)) {
AliExternalTrackParam *tpcTrack = (AliExternalTrackParam *)track->GetTPCInnerParam();
if(!tpcTrack) continue;
gPt = tpcTrack->Pt();
- gP = tpcTrack->P();
-
+ gP = track->GetInnerParam()->P();
tpcTrack->PropagateToDCA(vertex,
esd->GetMagneticField(),
100.,dca,cov);
-
- if(fProtonAnalysisBase->IsPrimary(esd,vertex,track)) {
- if(fProtonAnalysisBase->IsAccepted(track)) {
- ((TH2F *)(fQA2DList->At(0)))->Fill(gP,track->GetTPCsignal());
- ((TH2F *)(fQA2DList->At(2)))->Fill(gP,TMath::Log(track->GetTPCsignal()/tpcResponse.GetExpectedSignal(gP,AliPID::kProton)));
- ((TH3F *)(fQA2DList->At(4)))->Fill(tpcTrack->Eta(),
+ dca3D = TMath::Sqrt(TMath::Power(dca[0],2) +
+ TMath::Power(dca[1],2));
+
+ if(fProtonAnalysisBase->GetEtaMode())
+ containerInput[0] = tpcTrack->Eta();
+ else
+ containerInput[0] = fProtonAnalysisBase->Rapidity(tpcTrack->Px(),
+ tpcTrack->Py(),
+ tpcTrack->Pz());
+ containerInput[1] = gPt;
+
+ //Step: kStepSurvived
+ if(fProtonAnalysisBase->IsAccepted(track)) {
+ if(fProtonAnalysisBase->IsQARun()) {
+ ((TH2F *)(fQA2DList->At(1)))->Fill(gP,track->GetTPCsignal());
+ ((TH2F *)(fQA2DList->At(3)))->Fill(gP,TMath::Log(track->GetTPCsignal()/tpcResponse->GetExpectedSignal(gP,AliPID::kProton)));
+ ((TH3F *)(fQA2DList->At(5)))->Fill(tpcTrack->Eta(),
tpcTrack->Phi()*180./TMath::Pi(),
npointsTPCdEdx);
- ((TH3F *)(fQA2DList->At(6)))->Fill(tpcTrack->Eta(),
+ ((TH3F *)(fQA2DList->At(7)))->Fill(tpcTrack->Eta(),
tpcTrack->Phi()*180./TMath::Pi(),
nClustersTPC);
- ((TH3F *)(fQA2DList->At(8)))->Fill(gPt,
+ ((TH3F *)(fQA2DList->At(9)))->Fill(gPt,
tpcTrack->Phi()*180./TMath::Pi(),
npointsTPCdEdx);
- ((TH3F *)(fQA2DList->At(10)))->Fill(gPt,
- tpcTrack->Phi()*180./TMath::Pi(),
- nClustersTPC);
- }//quality cuts
- }//primary cuts
-
- if(fProtonAnalysisBase->IsProton(track)) {
- //Step: kStepIdentified
- if(fProtonAnalysisBase->GetEtaMode())
- containerInput[0] = tpcTrack->Eta();
- else
- containerInput[0] = fProtonAnalysisBase->Rapidity(tpcTrack->Px(),
- tpcTrack->Py(),
- tpcTrack->Pz());
- containerInput[1] = gPt;
+ ((TH3F *)(fQA2DList->At(11)))->Fill(gPt,
+ tpcTrack->Phi()*180./TMath::Pi(),
+ nClustersTPC);
+ }//run the qa
+
if(tpcTrack->Charge() > 0) {
- nIdentifiedProtons += 1;
- fProtonContainer->Fill(containerInput,kStepIdentified);
+ fProtonContainer->Fill(containerInput,kStepSurvived);
+ if(fProtonAnalysisBase->IsQARun()) {
+ ((TH2F *)(fQA2DList->At(12)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Phi()*180./TMath::Pi());
+ if(fProtonAnalysisBase->GetEtaMode()) {
+ ((TH3F *)(fQA2DList->At(14)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Pt(),
+ dca[0]);
+ ((TH3F *)(fQA2DList->At(15)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Pt(),
+ dca[1]);
+ ((TH3F *)(fQA2DList->At(18)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Pt(),
+ TMath::Abs(dca3D));
+ }
+ else {
+ ((TH3F *)(fQA2DList->At(14)))->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(),tpcTrack->Py(),tpcTrack->Pz()),
+ tpcTrack->Pt(),
+ dca[0]);
+ ((TH3F *)(fQA2DList->At(15)))->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(),tpcTrack->Py(),tpcTrack->Pz()),
+ tpcTrack->Pt(),
+ dca[1]);
+ ((TH3F *)(fQA2DList->At(18)))->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(),tpcTrack->Py(),tpcTrack->Pz()),
+ tpcTrack->Pt(),
+ TMath::Abs(dca3D));
+ }
+ }//run the qa
}//protons
else if(tpcTrack->Charge() < 0) {
- nIdentifiedAntiProtons += 1;
- fAntiProtonContainer->Fill(containerInput,kStepIdentified);
- }//protons
-
+ fAntiProtonContainer->Fill(containerInput,kStepSurvived);
+ if(fProtonAnalysisBase->IsQARun()) {
+ ((TH2F *)(fQA2DList->At(13)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Phi()*180./TMath::Pi());
+ if(fProtonAnalysisBase->GetEtaMode()) {
+ ((TH3F *)(fQA2DList->At(16)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Pt(),
+ dca[0]);
+ ((TH3F *)(fQA2DList->At(17)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Pt(),
+ dca[1]);
+ ((TH3F *)(fQA2DList->At(19)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Pt(),
+ TMath::Abs(dca3D));
+ }
+ else {
+ ((TH3F *)(fQA2DList->At(16)))->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(),tpcTrack->Py(),tpcTrack->Pz()),
+ tpcTrack->Pt(),
+ dca[0]);
+ ((TH3F *)(fQA2DList->At(17)))->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(),tpcTrack->Py(),tpcTrack->Pz()),
+ tpcTrack->Pt(),
+ dca[1]);
+ ((TH3F *)(fQA2DList->At(19)))->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(),tpcTrack->Py(),tpcTrack->Pz()),
+ tpcTrack->Pt(),
+ TMath::Abs(dca3D));
+ }
+ }//run the qa
+ }//antiprotons
+
//Step: kStepIsPrimary
if(fProtonAnalysisBase->IsPrimary(esd,vertex,track)) {
if(tpcTrack->Charge() > 0)
else if(tpcTrack->Charge() < 0)
fAntiProtonContainer->Fill(containerInput,kStepIsPrimary);
- FillQA(esd,vertex,track);
-
- //Step: kStepSurvived
- if(fProtonAnalysisBase->IsAccepted(track)) {
- ((TH2F *)(fQA2DList->At(1)))->Fill(gP,track->GetTPCsignal());
- ((TH2F *)(fQA2DList->At(3)))->Fill(gP,TMath::Log(track->GetTPCsignal()/tpcResponse.GetExpectedSignal(gP,AliPID::kProton)));
- ((TH3F *)(fQA2DList->At(5)))->Fill(tpcTrack->Eta(),
+ if(fProtonAnalysisBase->IsQARun()) {
+ ((TH2F *)(fQA2DList->At(0)))->Fill(gP,track->GetTPCsignal());
+ ((TH2F *)(fQA2DList->At(2)))->Fill(gP,TMath::Log(track->GetTPCsignal()/tpcResponse->GetExpectedSignal(gP,AliPID::kProton)));
+ ((TH3F *)(fQA2DList->At(4)))->Fill(tpcTrack->Eta(),
tpcTrack->Phi()*180./TMath::Pi(),
npointsTPCdEdx);
- ((TH3F *)(fQA2DList->At(7)))->Fill(tpcTrack->Eta(),
+ ((TH3F *)(fQA2DList->At(6)))->Fill(tpcTrack->Eta(),
tpcTrack->Phi()*180./TMath::Pi(),
nClustersTPC);
- ((TH3F *)(fQA2DList->At(9)))->Fill(gPt,
+ ((TH3F *)(fQA2DList->At(8)))->Fill(gPt,
tpcTrack->Phi()*180./TMath::Pi(),
npointsTPCdEdx);
- ((TH3F *)(fQA2DList->At(11)))->Fill(gPt,
+ ((TH3F *)(fQA2DList->At(10)))->Fill(gPt,
+ tpcTrack->Phi()*180./TMath::Pi(),
+ nClustersTPC);
+ if(track->Charge() > 0)
+ ((TH2F *)(fQA2DList->At(20)))->Fill(gP,track->GetTPCsignal());
+ if(track->Charge() < 0)
+ ((TH2F *)(fQA2DList->At(21)))->Fill(gP,track->GetTPCsignal());
+ }//run the qa
+
+ //Step: kStepIdentified
+ if(fProtonAnalysisBase->IsProton(track)) {
+ if(tpcTrack->Charge() > 0) {
+ nIdentifiedProtons += 1;
+ fProtonContainer->Fill(containerInput,kStepIdentified);
+ }//protons
+ else if(tpcTrack->Charge() < 0) {
+ nIdentifiedAntiProtons += 1;
+ fAntiProtonContainer->Fill(containerInput,kStepIdentified);
+ }//protons
+
+ if(fProtonAnalysisBase->IsQARun()) FillQA(esd,vertex,track);
+
+ //Step: kStepInPhaseSpace
+ if(fProtonAnalysisBase->IsInPhaseSpace(track)) {
+ if(tpcTrack->Charge() > 0) {
+ nSurvivedProtons += 1;
+ fHistYPtProtons->Fill(containerInput[0],
+ containerInput[1]);
+ fProtonContainer->Fill(containerInput,kStepInPhaseSpace);
+ }//protons
+ else if(tpcTrack->Charge() < 0) {
+ nSurvivedAntiProtons += 1;
+ fHistYPtAntiProtons->Fill(containerInput[0],
+ containerInput[1]);
+ fAntiProtonContainer->Fill(containerInput,kStepInPhaseSpace);
+ }//antiprotons
+ }//Step: kStepInPhaseSpace
+ }//Step: kStepIdentified
+ }//Step: kStepIsPrimary
+ }//Step: kStepSurvived
+ }//TPC only tracks
+ if(fProtonAnalysisBase->GetAnalysisMode()==AliProtonAnalysisBase::kFullHybrid) {
+ AliExternalTrackParam *tpcTrack = (AliExternalTrackParam *)track->GetTPCInnerParam();
+ if(!tpcTrack) continue;
+
+ AliExternalTrackParam cParam;
+ gPt = tpcTrack->Pt();
+ gP = track->GetInnerParam()->P();
+ track->RelateToVertex(vertex,
+ esd->GetMagneticField(),
+ 100.,&cParam);
+ track->GetImpactParameters(dcaXY,dcaZ);
+ dca[0] = dcaXY; dca[1] = dcaZ;
+ dca3D = TMath::Sqrt(TMath::Power(dca[0],2) +
+ TMath::Power(dca[1],2));
+ if(fProtonAnalysisBase->GetEtaMode())
+ containerInput[0] = tpcTrack->Eta();
+ else
+ containerInput[0] = fProtonAnalysisBase->Rapidity(tpcTrack->Px(),
+ tpcTrack->Py(),
+ tpcTrack->Pz());
+ containerInput[1] = gPt;
+
+ //Step: kStepSurvived
+ if(fProtonAnalysisBase->IsAccepted(track)) {
+ if(fProtonAnalysisBase->IsQARun()) {
+ ((TH2F *)(fQA2DList->At(1)))->Fill(gP,track->GetTPCsignal());
+ ((TH2F *)(fQA2DList->At(3)))->Fill(gP,TMath::Log(track->GetTPCsignal()/tpcResponse->GetExpectedSignal(gP,AliPID::kProton)));
+ ((TH3F *)(fQA2DList->At(5)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Phi()*180./TMath::Pi(),
+ npointsTPCdEdx);
+ ((TH3F *)(fQA2DList->At(7)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Phi()*180./TMath::Pi(),
+ nClustersTPC);
+ ((TH3F *)(fQA2DList->At(9)))->Fill(gPt,
+ tpcTrack->Phi()*180./TMath::Pi(),
+ npointsTPCdEdx);
+ ((TH3F *)(fQA2DList->At(11)))->Fill(gPt,
+ tpcTrack->Phi()*180./TMath::Pi(),
+ nClustersTPC);
+ }//run the qa
+ if(tpcTrack->Charge() > 0) {
+ fProtonContainer->Fill(containerInput,kStepSurvived);
+ if(fProtonAnalysisBase->IsQARun()) {
+ ((TH2F *)(fQA2DList->At(12)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Phi()*180./TMath::Pi());
+ if(fProtonAnalysisBase->GetEtaMode()) {
+ ((TH3F *)(fQA2DList->At(14)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Pt(),
+ dca[0]);
+ ((TH3F *)(fQA2DList->At(15)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Pt(),
+ dca[1]);
+ ((TH3F *)(fQA2DList->At(18)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Pt(),
+ TMath::Abs(dca3D));
+ }
+ else {
+ ((TH3F *)(fQA2DList->At(14)))->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(),tpcTrack->Py(),tpcTrack->Pz()),
+ tpcTrack->Pt(),
+ dca[0]);
+ ((TH3F *)(fQA2DList->At(15)))->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(),tpcTrack->Py(),tpcTrack->Pz()),
+ tpcTrack->Pt(),
+ dca[1]);
+ ((TH3F *)(fQA2DList->At(18)))->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(),tpcTrack->Py(),tpcTrack->Pz()),
+ tpcTrack->Pt(),
+ TMath::Abs(dca3D));
+ }
+ }//run the qa
+ }//protons
+ else if(tpcTrack->Charge() < 0) {
+ fAntiProtonContainer->Fill(containerInput,kStepSurvived);
+ if(fProtonAnalysisBase->IsQARun()) {
+ ((TH2F *)(fQA2DList->At(13)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Phi()*180./TMath::Pi());
+ if(fProtonAnalysisBase->GetEtaMode()) {
+ ((TH3F *)(fQA2DList->At(16)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Pt(),
+ dca[0]);
+ ((TH3F *)(fQA2DList->At(17)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Pt(),
+ dca[1]);
+ ((TH3F *)(fQA2DList->At(19)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Pt(),
+ TMath::Abs(dca3D));
+ }
+ else {
+ ((TH3F *)(fQA2DList->At(16)))->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(),tpcTrack->Py(),tpcTrack->Pz()),
+ tpcTrack->Pt(),
+ dca[0]);
+ ((TH3F *)(fQA2DList->At(17)))->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(),tpcTrack->Py(),tpcTrack->Pz()),
+ tpcTrack->Pt(),
+ dca[1]);
+ ((TH3F *)(fQA2DList->At(19)))->Fill(fProtonAnalysisBase->Rapidity(tpcTrack->Px(),tpcTrack->Py(),tpcTrack->Pz()),
+ tpcTrack->Pt(),
+ TMath::Abs(dca3D));
+ }
+ }//run the qa
+ }//antiprotons
+
+ //Step: kStepIsPrimary
+ if(fProtonAnalysisBase->IsPrimary(esd,vertex,track)) {
+ if(tpcTrack->Charge() > 0)
+ fProtonContainer->Fill(containerInput,kStepIsPrimary);
+ else if(tpcTrack->Charge() < 0)
+ fAntiProtonContainer->Fill(containerInput,kStepIsPrimary);
+
+ if(fProtonAnalysisBase->IsQARun()) {
+ ((TH2F *)(fQA2DList->At(0)))->Fill(gP,track->GetTPCsignal());
+ ((TH2F *)(fQA2DList->At(2)))->Fill(gP,TMath::Log(track->GetTPCsignal()/tpcResponse->GetExpectedSignal(gP,AliPID::kProton)));
+ ((TH3F *)(fQA2DList->At(4)))->Fill(tpcTrack->Eta(),
+ tpcTrack->Phi()*180./TMath::Pi(),
+ npointsTPCdEdx);
+ ((TH3F *)(fQA2DList->At(6)))->Fill(tpcTrack->Eta(),
tpcTrack->Phi()*180./TMath::Pi(),
nClustersTPC);
-
+ ((TH3F *)(fQA2DList->At(8)))->Fill(gPt,
+ tpcTrack->Phi()*180./TMath::Pi(),
+ npointsTPCdEdx);
+ ((TH3F *)(fQA2DList->At(10)))->Fill(gPt,
+ tpcTrack->Phi()*180./TMath::Pi(),
+ nClustersTPC);
+ if(track->Charge() > 0)
+ ((TH2F *)(fQA2DList->At(20)))->Fill(gP,track->GetTPCsignal());
+ if(track->Charge() < 0)
+ ((TH2F *)(fQA2DList->At(21)))->Fill(gP,track->GetTPCsignal());
+ }//run the qa
+
+ //Step: kStepIdentified
+ if(fProtonAnalysisBase->IsProton(track)) {
if(tpcTrack->Charge() > 0) {
- fProtonContainer->Fill(containerInput,kStepSurvived);
- ((TH2F *)(fQA2DList->At(12)))->Fill(tpcTrack->Eta(),
- tpcTrack->Phi()*180./TMath::Pi());
- ((TH2F *)(fQA2DList->At(14)))->Fill(tpcTrack->Pt(),
- TMath::Abs(dca[0]));
- ((TH2F *)(fQA2DList->At(15)))->Fill(tpcTrack->Pt(),
- TMath::Abs(dca[1]));
+ nIdentifiedProtons += 1;
+ fProtonContainer->Fill(containerInput,kStepIdentified);
}//protons
else if(tpcTrack->Charge() < 0) {
- fAntiProtonContainer->Fill(containerInput,kStepSurvived);
- ((TH2F *)(fQA2DList->At(13)))->Fill(tpcTrack->Eta(),
- tpcTrack->Phi()*180./TMath::Pi());
- ((TH2F *)(fQA2DList->At(16)))->Fill(tpcTrack->Pt(),
- TMath::Abs(dca[0]));
- ((TH2F *)(fQA2DList->At(17)))->Fill(tpcTrack->Pt(),
- TMath::Abs(dca[1]));
- }//antiprotons
+ nIdentifiedAntiProtons += 1;
+ fAntiProtonContainer->Fill(containerInput,kStepIdentified);
+ }//protons
+ if(fProtonAnalysisBase->IsQARun()) FillQA(esd,vertex,track);
+
//Step: kStepInPhaseSpace
if(fProtonAnalysisBase->IsInPhaseSpace(track)) {
if(tpcTrack->Charge() > 0) {
fAntiProtonContainer->Fill(containerInput,kStepInPhaseSpace);
}//antiprotons
}//Step: kStepInPhaseSpace
- }//Step: kStepSurvived
+ }//Step: kStepIdentified
}//Step: kStepIsPrimary
- }//Step: kStepIdentified
- }//TPC only tracks
+ }//Step: kStepSurvived
+ }//Full hybrid
else if(fProtonAnalysisBase->GetAnalysisMode() == AliProtonAnalysisBase::kGlobal) {
gPt = track->Pt();
- gP = track->P();
+ gP = track->GetInnerParam()->P();
+
track->PropagateToDCA(vertex,
esd->GetMagneticField(),
100.,dca,cov);
+ dca3D = TMath::Sqrt(TMath::Power(dca[0],2) +
+ TMath::Power(dca[1],2));
+
+ if(fProtonAnalysisBase->GetEtaMode())
+ containerInput[0] = track->Eta();
+ else
+ containerInput[0] = fProtonAnalysisBase->Rapidity(track->Px(),
+ track->Py(),
+ track->Pz());
+ containerInput[1] = gPt;
- if(fProtonAnalysisBase->IsPrimary(esd,vertex,track)) {
- if(fProtonAnalysisBase->IsAccepted(track)) {
- ((TH2F *)(fQA2DList->At(0)))->Fill(gP,track->GetTPCsignal());
- ((TH2F *)(fQA2DList->At(2)))->Fill(gP,TMath::Log(track->GetTPCsignal()/tpcResponse.GetExpectedSignal(gP,AliPID::kProton)));
- ((TH3F *)(fQA2DList->At(4)))->Fill(track->Eta(),
+ //Step: kStepSurvived
+ if(fProtonAnalysisBase->IsAccepted(track)) {
+ if(fProtonAnalysisBase->IsQARun()) {
+ ((TH2F *)(fQA2DList->At(1)))->Fill(gP,track->GetTPCsignal());
+ ((TH2F *)(fQA2DList->At(3)))->Fill(gP,TMath::Log(track->GetTPCsignal()/tpcResponse->GetExpectedSignal(gP,AliPID::kProton)));
+ ((TH3F *)(fQA2DList->At(5)))->Fill(track->Eta(),
track->Phi()*180./TMath::Pi(),
npointsTPCdEdx);
- ((TH3F *)(fQA2DList->At(6)))->Fill(track->Eta(),
+ ((TH3F *)(fQA2DList->At(7)))->Fill(track->Eta(),
track->Phi()*180./TMath::Pi(),
nClustersTPC);
- ((TH3F *)(fQA2DList->At(8)))->Fill(gPt,
+ ((TH3F *)(fQA2DList->At(9)))->Fill(gPt,
track->Phi()*180./TMath::Pi(),
npointsTPCdEdx);
- ((TH3F *)(fQA2DList->At(10)))->Fill(gPt,
- track->Phi()*180./TMath::Pi(),
- nClustersTPC);
- }//quality cuts
- }//primary cuts
-
- if(fProtonAnalysisBase->IsProton(track)) {
- //Step: kStepIdentified
- if(fProtonAnalysisBase->GetEtaMode())
- containerInput[0] = track->Eta();
- else
- containerInput[0] = fProtonAnalysisBase->Rapidity(track->Px(),
- track->Py(),
- track->Pz());
- containerInput[1] = gPt;
+ ((TH3F *)(fQA2DList->At(11)))->Fill(gPt,
+ track->Phi()*180./TMath::Pi(),
+ nClustersTPC);
+ }//run the qa
if(track->Charge() > 0) {
- nIdentifiedProtons += 1;
- fProtonContainer->Fill(containerInput,kStepIdentified);
+ fProtonContainer->Fill(containerInput,kStepSurvived);
+ if(fProtonAnalysisBase->IsQARun()) {
+ ((TH2F *)(fQA2DList->At(12)))->Fill(track->Eta(),
+ track->Phi()*180./TMath::Pi());
+ if(fProtonAnalysisBase->GetEtaMode()) {
+ ((TH3F *)(fQA2DList->At(14)))->Fill(track->Eta(),
+ track->Pt(),
+ dca[0]);
+ ((TH3F *)(fQA2DList->At(15)))->Fill(track->Eta(),
+ track->Pt(),
+ dca[1]);
+ ((TH3F *)(fQA2DList->At(18)))->Fill(track->Eta(),
+ track->Pt(),
+ TMath::Abs(dca3D));
+ }
+ else {
+ ((TH3F *)(fQA2DList->At(14)))->Fill(fProtonAnalysisBase->Rapidity(track->Px(),track->Py(),track->Pz()),
+ track->Pt(),
+ dca[0]);
+ ((TH3F *)(fQA2DList->At(15)))->Fill(fProtonAnalysisBase->Rapidity(track->Px(),track->Py(),track->Pz()),
+ track->Pt(),
+ dca[1]);
+ ((TH3F *)(fQA2DList->At(18)))->Fill(fProtonAnalysisBase->Rapidity(track->Px(),track->Py(),track->Pz()),
+ track->Pt(),
+ TMath::Abs(dca3D));
+ }
+ }//run the qa
}//protons
else if(track->Charge() < 0) {
- nIdentifiedAntiProtons += 1;
- fAntiProtonContainer->Fill(containerInput,kStepIdentified);
- }//protons
+ fAntiProtonContainer->Fill(containerInput,kStepSurvived);
+ if(fProtonAnalysisBase->IsQARun()) {
+ ((TH2F *)(fQA2DList->At(13)))->Fill(track->Eta(),
+ track->Phi()*180./TMath::Pi());
+ if(fProtonAnalysisBase->GetEtaMode()) {
+ ((TH3F *)(fQA2DList->At(16)))->Fill(track->Eta(),
+ track->Pt(),
+ dca[0]);
+ ((TH3F *)(fQA2DList->At(17)))->Fill(track->Eta(),
+ track->Pt(),
+ dca[1]);
+ ((TH3F *)(fQA2DList->At(19)))->Fill(track->Eta(),
+ track->Pt(),
+ TMath::Abs(dca3D));
+ }
+ else {
+ ((TH3F *)(fQA2DList->At(16)))->Fill(fProtonAnalysisBase->Rapidity(track->Px(),track->Py(),track->Pz()),
+ track->Pt(),
+ dca[0]);
+ ((TH3F *)(fQA2DList->At(17)))->Fill(fProtonAnalysisBase->Rapidity(track->Px(),track->Py(),track->Pz()),
+ track->Pt(),
+ dca[1]);
+ ((TH3F *)(fQA2DList->At(19)))->Fill(fProtonAnalysisBase->Rapidity(track->Px(),track->Py(),track->Pz()),
+ track->Pt(),
+ TMath::Abs(dca3D));
+ }
+ }//run the qa
+ }//antiprotons
//Step: kStepIsPrimary
if(fProtonAnalysisBase->IsPrimary(esd,vertex,track)) {
else if(track->Charge() < 0)
fAntiProtonContainer->Fill(containerInput,kStepIsPrimary);
- FillQA(esd,vertex,track);
-
- //Step: kStepSurvived
- if(fProtonAnalysisBase->IsAccepted(track)) {
- ((TH2F *)(fQA2DList->At(1)))->Fill(gP,track->GetTPCsignal());
- ((TH2F *)(fQA2DList->At(3)))->Fill(gP,TMath::Log(track->GetTPCsignal()/tpcResponse.GetExpectedSignal(gP,AliPID::kProton)));
- ((TH3F *)(fQA2DList->At(5)))->Fill(track->Eta(),
+ if(fProtonAnalysisBase->IsQARun()) {
+ ((TH2F *)(fQA2DList->At(0)))->Fill(gP,track->GetTPCsignal());
+ ((TH2F *)(fQA2DList->At(2)))->Fill(gP,TMath::Log(track->GetTPCsignal()/tpcResponse->GetExpectedSignal(gP,AliPID::kProton)));
+ ((TH3F *)(fQA2DList->At(4)))->Fill(track->Eta(),
track->Phi()*180./TMath::Pi(),
npointsTPCdEdx);
- ((TH3F *)(fQA2DList->At(7)))->Fill(track->Eta(),
+ ((TH3F *)(fQA2DList->At(6)))->Fill(track->Eta(),
track->Phi()*180./TMath::Pi(),
nClustersTPC);
- ((TH3F *)(fQA2DList->At(9)))->Fill(gPt,
+ ((TH3F *)(fQA2DList->At(8)))->Fill(gPt,
track->Phi()*180./TMath::Pi(),
npointsTPCdEdx);
- ((TH3F *)(fQA2DList->At(11)))->Fill(gPt,
- track->Phi()*180./TMath::Pi(),
- nClustersTPC);
-
+ ((TH3F *)(fQA2DList->At(10)))->Fill(gPt,
+ track->Phi()*180./TMath::Pi(),
+ nClustersTPC);
+ if(track->Charge() > 0)
+ ((TH2F *)(fQA2DList->At(20)))->Fill(gP,track->GetTPCsignal());
+ if(track->Charge() < 0)
+ ((TH2F *)(fQA2DList->At(21)))->Fill(gP,track->GetTPCsignal());
+ }//run the qa
+
+ //Step: kStepIdentified
+ if(fProtonAnalysisBase->IsProton(track)) {
if(track->Charge() > 0) {
- fProtonContainer->Fill(containerInput,kStepSurvived);
- ((TH2F *)(fQA2DList->At(12)))->Fill(track->Eta(),
- track->Phi()*180./TMath::Pi());
- ((TH2F *)(fQA2DList->At(14)))->Fill(track->Pt(),
- TMath::Abs(dca[0]));
- ((TH2F *)(fQA2DList->At(15)))->Fill(track->Pt(),
- TMath::Abs(dca[1]));
+ nIdentifiedProtons += 1;
+ fProtonContainer->Fill(containerInput,kStepIdentified);
}//protons
else if(track->Charge() < 0) {
- fAntiProtonContainer->Fill(containerInput,kStepSurvived);
- ((TH2F *)(fQA2DList->At(13)))->Fill(track->Eta(),
- track->Phi()*180./TMath::Pi());
- ((TH2F *)(fQA2DList->At(16)))->Fill(track->Pt(),
- TMath::Abs(dca[0]));
- ((TH2F *)(fQA2DList->At(17)))->Fill(track->Pt(),
- TMath::Abs(dca[1]));
- }//antiprotons
+ nIdentifiedAntiProtons += 1;
+ fAntiProtonContainer->Fill(containerInput,kStepIdentified);
+ }//protons
+
+ if(fProtonAnalysisBase->IsQARun()) FillQA(esd,vertex,track);
//Step: kStepInPhaseSpace
if(fProtonAnalysisBase->IsInPhaseSpace(track)) {
fAntiProtonContainer->Fill(containerInput,kStepInPhaseSpace);
}//antiprotons
}//Step: kStepInPhaseSpace
- }//Step: kStepSurvived
+ }//Step: kStepIdentified
}//Step: kStepIsPrimary
- }//Step: kStepIdentified
+ }//Step: kStepSurvived
}//Global tracking
}//track loop
+ delete tpcResponse;
+
if((nIdentifiedProtons > 0)||(nIdentifiedAntiProtons > 0))
fHistEvents->Fill(2); //number of analyzed events with at least one (anti)proton
-
+
if(fProtonAnalysisBase->GetDebugMode())
Printf("Initial number of tracks: %d | Identified (anti)protons: %d - %d | Survived (anti)protons: %d - %d",nTracks,nIdentifiedProtons,nIdentifiedAntiProtons,nSurvivedProtons,nSurvivedAntiProtons);
}
//____________________________________________________________________//
void AliProtonAnalysis::Analyze(AliAODEvent* const fAOD) {
//Main analysis part - AOD
+ if(!fProtonAnalysisBase) return;
fHistEvents->Fill(1); //number of analyzed events
Int_t nTracks = fAOD->GetNumberOfTracks();
for(Int_t iTracks = 0; iTracks < nTracks; iTracks++) {
void AliProtonAnalysis::Analyze(AliStack* const stack,
Bool_t iInclusive) {
//Main analysis part - MC
+ if(!fProtonAnalysisBase) return;
fHistEvents->Fill(1); //number of analyzed events
Int_t nParticles = 0;
//____________________________________________________________________//
Bool_t AliProtonAnalysis::PrintMean(TH1 *hist, Double_t edge) {
//calculates the mean value of the ratio/asymmetry within \pm edge
- Double_t sum = 0.0;
+ Double_t sum = 0.0, sumError = 0.0;
Int_t nentries = 0;
//calculate the mean
- for(Int_t i = 0; i < hist->GetXaxis()->GetNbins(); i++) {
- Double_t x = hist->GetBinCenter(i+1);
- Double_t y = hist->GetBinContent(i+1);
+ for(Int_t i = 1; i <= hist->GetXaxis()->GetNbins(); i++) {
+ Double_t x = hist->GetBinCenter(i);
+ Double_t y = hist->GetBinContent(i);
if(TMath::Abs(x) < edge) {
sum += y;
+ sumError += TMath::Power(hist->GetBinError(i),2);
nentries += 1;
}
+ //Printf("eta: %lf - sum: %lf - sumError: %lf - counter: %d",
+ //TMath::Abs(x),sum,sumError,nentries);
}
Double_t mean = 0.0;
- if(nentries != 0)
+ Double_t error = 0.0;
+ if(nentries != 0) {
mean = sum/nentries;
+ error = TMath::Sqrt(sumError)/nentries;
+ }
//calculate the error
- for(Int_t i = 0; i < hist->GetXaxis()->GetNbins(); i++) {
- Double_t x = hist->GetBinCenter(i+1);
- Double_t y = hist->GetBinContent(i+1);
+ /*for(Int_t i = 1; i <= hist->GetXaxis()->GetNbins(); i++) {
+ Double_t x = hist->GetBinCenter(i);
+ Double_t y = hist->GetBinContent(i);
if(TMath::Abs(x) < edge) {
sum += TMath::Power((mean - y),2);
nentries += 1;
}
- }
+ }*/
- Double_t error = 0.0;
- if(nentries != 0)
- error = TMath::Sqrt(sum)/nentries;
cout<<"========================================="<<endl;
cout<<"Input distribution: "<<hist->GetName()<<endl;
return 0;
}
+//____________________________________________________________________//
+void AliProtonAnalysis::SetCorrectionMapForCuts(const char* filename) {
+ //Reads the file with the correction maps for the cut efficiency
+ TFile *gCorrectionForCuts = TFile::Open(filename);
+ if(!gCorrectionForCuts) {
+ Printf("The TFile object is not valid!!!");
+ return;
+ }
+ if(!gCorrectionForCuts->IsOpen()) {
+ Printf("The file is not found!!!");
+ return;
+ }
+ fHistYPtCorrectionForCutsProtons = dynamic_cast<TH2D *>(gCorrectionForCuts->Get("gHistCorrectionForCutsProtons"));
+ fHistYPtCorrectionForCutsAntiProtons = dynamic_cast<TH2D *>(gCorrectionForCuts->Get("gHistCorrectionForCutsAntiProtons"));
+ fCorrectForCutsFlag = kTRUE;
+}
+
+//____________________________________________________________________//
+void AliProtonAnalysis::SetCorrectionMapForTracking(const char* filename) {
+ //Reads the file with the correction maps for the tracking efficiency
+ TFile *gCorrectionForTracking = TFile::Open(filename);
+ if(!gCorrectionForTracking) {
+ Printf("The TFile object is not valid!!!");
+ return;
+ }
+ if(!gCorrectionForTracking->IsOpen()) {
+ Printf("The file is not found!!!");
+ return;
+ }
+ fHistYPtCorrectionForTrackingProtons = dynamic_cast<TH2D *>(gCorrectionForTracking->Get("gHistCorrectionForTrackingProtons"));
+ fHistYPtCorrectionForTrackingAntiProtons = dynamic_cast<TH2D *>(gCorrectionForTracking->Get("gHistCorrectionForTrackingAntiProtons"));
+ fCorrectForTrackingFlag = kTRUE;
+}
+
+//____________________________________________________________________//
+void AliProtonAnalysis::SetCorrectionMapForFeedDown(const char* filename) {
+ //Reads the file with the correction maps for the feed-down contamination
+ TFile *gCorrectionForFeedDown = TFile::Open(filename);
+ if(!gCorrectionForFeedDown) {
+ Printf("The TFile object is not valid!!!");
+ return;
+ }
+ if(!gCorrectionForFeedDown->IsOpen()) {
+ Printf("The file is not found!!!");
+ return;
+ }
+ fHistYPtCorrectionForFeedDownProtons = dynamic_cast<TH2D *>(gCorrectionForFeedDown->Get("gHistCorrectionForFeedDownProtons"));
+ fHistYPtCorrectionForFeedDownAntiProtons = dynamic_cast<TH2D *>(gCorrectionForFeedDown->Get("gHistCorrectionForFeedDownAntiProtons"));
+ fCorrectForFeedDownFlag = kTRUE;
+}
+
+//____________________________________________________________________//
+void AliProtonAnalysis::SetCorrectionMapForSecondaries(const char* filename) {
+ //Reads the file with the correction maps for the secondaries
+ TFile *gCorrectionForSecondaries = TFile::Open(filename);
+ if(!gCorrectionForSecondaries) {
+ Printf("The TFile object is not valid!!!");
+ return;
+ }
+ if(!gCorrectionForSecondaries->IsOpen()) {
+ Printf("The file is not found!!!");
+ return;
+ }
+
+ fHistYPtCorrectionForSecondaries = dynamic_cast<TH2D *>(gCorrectionForSecondaries->Get("gHistCorrectionForSecondaries"));
+ fCorrectForSecondariesFlag = kTRUE;
+}
+
+//____________________________________________________________________//
+void AliProtonAnalysis::SetCorrectionMapForCrossSection(const char* filename) {
+ //Reads the file with the correction maps for the proper x-section
+ TFile *gCorrectionForXSection = TFile::Open(filename);
+ if(!gCorrectionForXSection) {
+ Printf("The TFile object is not valid!!!");
+ return;
+ }
+ if(!gCorrectionForXSection->IsOpen()) {
+ Printf("The file is not found!!!");
+ return;
+ }
+
+ fHistCorrectionForCrossSectionYPtProtons = dynamic_cast<TH2D *>(gCorrectionForXSection->Get("gHistCorrectionForCrossSectionProtons"));
+ fHistCorrectionForCrossSectionYPtAntiProtons = dynamic_cast<TH2D *>(gCorrectionForXSection->Get("gHistCorrectionForCrossSectionAntiProtons"));
+ fHistCorrectionForCrossSectionFlag = kTRUE;
+}
+
+//____________________________________________________________________//
+void AliProtonAnalysis::Correct() {
+ //Apply the corrections: Fast & dirty way for the absorption corrections
+ //Correct the protons for the efficiency
+ fHistYPtProtonsCorrected = fProtonContainer->ShowProjection(0,1,kStepInPhaseSpace);
+ fHistYPtProtonsCorrected->Divide(fHistEfficiencyYPtProtons);
+ //Correct the protons for proper cross-section
+ if(fHistCorrectionForCrossSectionFlag)
+ fHistYPtProtonsCorrected->Multiply(fHistCorrectionForCrossSectionYPtProtons);
+ //Correct the protons for secondaries
+ if(fCorrectForSecondariesFlag)
+ fHistYPtProtonsCorrected->Divide(fHistYPtCorrectionForSecondaries);
+ //Correct the protons for feed-down
+ if(fCorrectForFeedDownFlag)
+ fHistYPtProtonsCorrected->Divide(fHistYPtCorrectionForFeedDownProtons);
+ //Correct the protons for the cut efficiency
+ if(fCorrectForCutsFlag)
+ fHistYPtProtonsCorrected->Multiply(fHistYPtCorrectionForCutsProtons);
+ //Correct the protons for the tracking efficiency
+ if(fCorrectForTrackingFlag)
+ fHistYPtProtonsCorrected->Multiply(fHistYPtCorrectionForTrackingProtons);
+
+ //Correct the antiprotons for the efficiency
+ fHistYPtAntiProtonsCorrected = fAntiProtonContainer->ShowProjection(0,1,kStepInPhaseSpace);
+ fHistYPtAntiProtonsCorrected->Divide(fHistEfficiencyYPtAntiProtons);
+ //Correct the antiprotons for proper cross-section
+ if(fHistCorrectionForCrossSectionFlag)
+ fHistYPtAntiProtonsCorrected->Multiply(fHistCorrectionForCrossSectionYPtAntiProtons);
+ //Correct the antiprotons for feed-down
+ if(fCorrectForFeedDownFlag)
+ fHistYPtAntiProtonsCorrected->Divide(fHistYPtCorrectionForFeedDownAntiProtons);
+ //Correct the antiprotons for the cut efficiency
+ if(fCorrectForCutsFlag)
+ fHistYPtAntiProtonsCorrected->Multiply(fHistYPtCorrectionForCutsAntiProtons);
+ //Correct the antiprotons for the tracking efficiency
+ if(fCorrectForTrackingFlag)
+ fHistYPtAntiProtonsCorrected->Multiply(fHistYPtCorrectionForTrackingAntiProtons);
+}
+
//____________________________________________________________________//
void AliProtonAnalysis::Correct(Int_t step) {
//Applies the correction maps to the initial containers
fCorrectProtons = new AliCFDataGrid("correctProtons",
"corrected data",
- *fProtonContainer);
- fCorrectProtons->SetMeasured(0);
+ *fProtonContainer,0);
+ //fCorrectProtons->SetMeasured(0);
fCorrectProtons->ApplyEffCorrection(*(AliCFEffGrid *)fEffGridListProtons->At(step));
fCorrectAntiProtons = new AliCFDataGrid("correctAntiProtons",
"corrected data",
- *fAntiProtonContainer);
- fCorrectAntiProtons->SetMeasured(0);
+ *fAntiProtonContainer,0);
+ //fCorrectAntiProtons->SetMeasured(0);
fCorrectAntiProtons->ApplyEffCorrection(*(AliCFEffGrid *)fEffGridListAntiProtons->At(step));
}
// Puts the results in the different TList objects
Bool_t status = kTRUE;
+ TFile *file = TFile::Open(filename);
+ if(!file) {
+ cout<<"Could not find the input CORRFW file "<<filename<<endl;
+ status = kFALSE;
+ }
+ else {
+ TList *list = dynamic_cast<TList *>(file->Get("outputList"));
+ Int_t iRap = 0, iPt = 1;
+ if (list){
+ //Calculation of efficiency/correction: Protons
+ AliCFContainer *gProtonContainer = dynamic_cast<AliCFContainer *>(list->At(0));
+ AliCFContainer *gAntiProtonContainer = dynamic_cast<AliCFContainer *>(list->At(1));
+
+ if (gProtonContainer && gAntiProtonContainer){
+ AliCFEffGrid *effProtonsStep0Step2 = new AliCFEffGrid("eff20",
+ "effProtonsStep0Step2",
+ *gProtonContainer);
+ effProtonsStep0Step2->CalculateEfficiency(2,0);
+ fHistEfficiencyYPtProtons = (TH2D*)effProtonsStep0Step2->Project(iRap,iPt);
+ fHistEfficiencyYPtProtons->Sumw2();
+
+ //Calculation of efficiency/correction: Protons
+ AliCFEffGrid *effAntiProtonsStep0Step2 = new AliCFEffGrid("eff20",
+ "effAntiProtonsStep0Step2",
+ *gAntiProtonContainer);
+ effAntiProtonsStep0Step2->CalculateEfficiency(2,0);
+ fHistEfficiencyYPtAntiProtons = (TH2D*)effAntiProtonsStep0Step2->Project(iRap,iPt);
+ fHistEfficiencyYPtAntiProtons->Sumw2();
+
+ Correct();
+ }
+ else {
+ cout<<"Could not retreive the proton and anti-proton correction containers"<<endl;
+ status = kFALSE;
+ }
+ }
+ else {
+ cout<<"Could not retreive the output list from the CORRW file"<<endl;
+ status = kFALSE;
+ }
+ }
+ return status;
+}
+
+//____________________________________________________________________//
+/*Bool_t AliProtonAnalysis::ReadCorrectionContainer(const char* filename) {
+ // Reads the outout of the correction framework task
+ // Creates the correction maps
+ // Puts the results in the different TList objects
+ Bool_t status = kTRUE;
+
TFile *file = TFile::Open(filename);
if(!file) {
cout<<"Could not find the input CORRFW file "<<filename<<endl;
}
return status;
-}
+ }*/
//____________________________________________________________________//
void AliProtonAnalysis::InitQA() {
+ if(!fProtonAnalysisBase) return;
//Applies the correction maps to the initial containers
- fInitQAFlag = kTRUE;
fGlobalQAList = new TList();
fGlobalQAList->SetName("fGlobalQAList");
gHistAntiProtonsEtaPhi->SetStats(kTRUE);
fQA2DList->Add(gHistAntiProtonsEtaPhi);
+ const Int_t nBinsdca = 1000;
+ Double_t dcaBins[nBinsdca+1];
+ Double_t dcamin = -5., dcamax = 5.;
+ Double_t dca = -5.;
+ Double_t dcaStepSmall = 0.01;
+ Int_t iCounter = 0;
+ while(dca <= 5.) {
+ dcaBins[iCounter] = dcamin;
+ dcamax = dcamin + dcaStepSmall;
+ dca = dcamax;
+ dcamin = dcamax;
+ iCounter += 1;
+ }
+
+ const Int_t nBinsY = 9;
+ const Int_t nBinsPt = 6;
+ Double_t gY[nBinsY+1] = {-0.9,-0.7,-0.5,-0.3,-0.1,0.1,0.3,0.5,0.7,0.9};
+ Double_t gPt[nBinsPt+1] = {0.45,0.55,0.65,0.75,0.85,0.95,1.05};
+
//dca vs pT for protons & antiprotons
- TH2F *gHistProtonsDCAxyPt = new TH2F("gHistProtonsDCAxyPt",
- ";P_{T} [GeV/c];dca_{xy} [cm]",
- 16,0.3,1.1,
- 1000,0,10);
- gHistProtonsDCAxyPt->SetStats(kTRUE);
- fQA2DList->Add(gHistProtonsDCAxyPt);
- TH2F *gHistProtonsDCAzPt = new TH2F("gHistProtonsDCAzPt",
- ";P_{T} [GeV/c];dca_{z} [cm]",
- 16,0.3,1.1,
- 1000,0,10);
- gHistProtonsDCAzPt->SetStats(kTRUE);
- fQA2DList->Add(gHistProtonsDCAzPt);
- TH2F *gHistAntiProtonsDCAxyPt = new TH2F("gHistAntiProtonsDCAxyPt",
- ";P_{T} [GeV/c];dca_{xy} [cm]",
- 16,0.3,1.1,
- 1000,0,10);
- gHistAntiProtonsDCAxyPt->SetStats(kTRUE);
- fQA2DList->Add(gHistAntiProtonsDCAxyPt);
- TH2F *gHistAntiProtonsDCAzPt = new TH2F("gHistAntiProtonsDCAzPt",
- ";P_{T} [GeV/c];dca_{z} [cm]",
- 16,0.3,1.1,
- 1000,0,10);
- gHistAntiProtonsDCAzPt->SetStats(kTRUE);
- fQA2DList->Add(gHistAntiProtonsDCAzPt);
+ TH3F *gHistProtonsDCAxyEtaPt = new TH3F("gHistProtonsDCAxyEtaPt",
+ ";P_{T} [GeV/c];dca_{xy} [cm]",
+ nBinsY,gY,nBinsPt,gPt,
+ nBinsdca,dcaBins);
+ if(fProtonAnalysisBase->GetEtaMode())
+ gHistProtonsDCAxyEtaPt->GetXaxis()->SetTitle("#eta");
+ else
+ gHistProtonsDCAxyEtaPt->GetXaxis()->SetTitle("y");
+ gHistProtonsDCAxyEtaPt->SetStats(kTRUE);
+ fQA2DList->Add(gHistProtonsDCAxyEtaPt);
+ TH3F *gHistProtonsDCAzEtaPt = new TH3F("gHistProtonsDCAzEtaPt",
+ ";P_{T} [GeV/c];dca_{z} [cm]",
+ nBinsY,gY,nBinsPt,gPt,
+ nBinsdca,dcaBins);
+ if(fProtonAnalysisBase->GetEtaMode())
+ gHistProtonsDCAzEtaPt->GetXaxis()->SetTitle("#eta");
+ else
+ gHistProtonsDCAzEtaPt->GetXaxis()->SetTitle("y");
+ gHistProtonsDCAzEtaPt->SetStats(kTRUE);
+ fQA2DList->Add(gHistProtonsDCAzEtaPt);
+ TH3F *gHistAntiProtonsDCAxyEtaPt = new TH3F("gHistAntiProtonsDCAxyEtaPt",
+ ";P_{T} [GeV/c];dca_{xy} [cm]",
+ nBinsY,gY,nBinsPt,gPt,
+ nBinsdca,dcaBins);
+ if(fProtonAnalysisBase->GetEtaMode())
+ gHistAntiProtonsDCAxyEtaPt->GetXaxis()->SetTitle("#eta");
+ else
+ gHistAntiProtonsDCAxyEtaPt->GetXaxis()->SetTitle("y");
+ gHistAntiProtonsDCAxyEtaPt->SetStats(kTRUE);
+ fQA2DList->Add(gHistAntiProtonsDCAxyEtaPt);
+ TH3F *gHistAntiProtonsDCAzEtaPt = new TH3F("gHistAntiProtonsDCAzEtaPt",
+ ";P_{T} [GeV/c];dca_{z} [cm]",
+ nBinsY,gY,nBinsPt,gPt,
+ nBinsdca,dcaBins);
+ if(fProtonAnalysisBase->GetEtaMode())
+ gHistAntiProtonsDCAzEtaPt->GetXaxis()->SetTitle("#eta");
+ else
+ gHistAntiProtonsDCAzEtaPt->GetXaxis()->SetTitle("y");
+ gHistAntiProtonsDCAzEtaPt->SetStats(kTRUE);
+ fQA2DList->Add(gHistAntiProtonsDCAzEtaPt);
+
+ TH3F *gHistProtonsDCA3DEtaPt = new TH3F("gHistProtonsDCA3DEtaPt",
+ ";P_{T} [GeV/c];dca [cm]",
+ fNBinsY,fMinY,fMaxY,
+ fNBinsPt,fMinPt,fMaxPt,
+ 100,0,20);
+ if(fProtonAnalysisBase->GetEtaMode())
+ gHistProtonsDCA3DEtaPt->GetXaxis()->SetTitle("#eta");
+ else
+ gHistProtonsDCA3DEtaPt->GetXaxis()->SetTitle("y");
+ gHistProtonsDCA3DEtaPt->SetStats(kTRUE);
+ fQA2DList->Add(gHistProtonsDCA3DEtaPt);
+ TH3F *gHistAntiProtonsDCA3DEtaPt = new TH3F("gHistAntiProtonsDCA3DEtaPt",
+ ";P_{T} [GeV/c];dca [cm]",
+ fNBinsY,fMinY,fMaxY,
+ fNBinsPt,fMinPt,fMaxPt,
+ 100,0,20);
+ if(fProtonAnalysisBase->GetEtaMode())
+ gHistAntiProtonsDCA3DEtaPt->GetXaxis()->SetTitle("#eta");
+ else
+ gHistAntiProtonsDCA3DEtaPt->GetXaxis()->SetTitle("y");
+ gHistAntiProtonsDCA3DEtaPt->SetStats(kTRUE);
+ fQA2DList->Add(gHistAntiProtonsDCA3DEtaPt);
+
+ TH2F *gHistPosdEdxP = new TH2F("gHistPosdEdxP","dE/dx (TPC); P [GeV/c]; dE/dx [a.u]",1000,0.05,20.05,600,0,600);
+ fQA2DList->Add(gHistPosdEdxP);
+ TH2F *gHistNegdEdxP = new TH2F("gHistNegdEdxP","dE/dx (TPC); P [GeV/c]; dE/dx [a.u]",1000,0.05,20.05,600,0,600);
+ fQA2DList->Add(gHistNegdEdxP);
//========================================================//
fQAProtonsAcceptedList = new TList();
fQAProtonsAcceptedList->Add(gProtonsExtCov55Pass);
TH1F *gProtonsSigmaToVertexPass = new TH1F("gProtonsSigmaToVertexPass",
";#sigma_{Vertex};Entries",
- 100,0,10);
+ 100,0.,10.);
fQAProtonsAcceptedList->Add(gProtonsSigmaToVertexPass);
TH1F *gProtonsSigmaToVertexTPCPass = new TH1F("gProtonsSigmaToVertexTPCPass",
";#sigma_{Vertex};Entries",
- 100,0,10);
+ 100,0.,10.);
fQAProtonsAcceptedList->Add(gProtonsSigmaToVertexTPCPass);
TH1F *gProtonsDCAXYPass = new TH1F("gProtonsDCAXYPass",
";DCA_{xy} [cm];Entries",
fQAProtonsAcceptedList->Add(gProtonsPointOnITSLayer6Pass);
TH1F *gProtonsNumberOfTPCdEdxPointsPass = new TH1F("gProtonsNumberOfTPCdEdxPointsPass","",100,0,200);
fQAProtonsAcceptedList->Add(gProtonsNumberOfTPCdEdxPointsPass);
+ TH1F *gProtonsITSClusterMapPass = new TH1F("gProtonsITSClusterMapPass",";ITS Layer;Entries",6,0.5,6.5);
+ fQAProtonsAcceptedList->Add(gProtonsITSClusterMapPass);
+ TH1F *gProtonsDCA3DPass = new TH1F("gProtonsDCA3DPass",
+ ";dca [cm];Entries",
+ 100,0,20);
+ fQAProtonsAcceptedList->Add(gProtonsDCA3DPass);
//========================================================//
fQAProtonsRejectedList = new TList();
TH1F *gProtonsNumberOfTPCdEdxPointsReject = new TH1F("gProtonsNumberOfTPCdEdxPointsReject","",100,0,200);
gProtonsNumberOfTPCdEdxPointsReject->SetFillColor(kRed-2);
fQAProtonsRejectedList->Add(gProtonsNumberOfTPCdEdxPointsReject);
+ TH1F *gProtonsITSClusterMapReject = new TH1F("gProtonsITSClusterMapReject",";ITS Layer;Entries",6,0.5,6.5);
+ gProtonsITSClusterMapReject->SetFillColor(kRed-2);
+ fQAProtonsRejectedList->Add(gProtonsITSClusterMapReject);
+ TH1F *gProtonsDCA3DReject = new TH1F("gProtonsDCA3DReject",
+ ";dca [cm];Entries",
+ 100,0,20);
+ gProtonsDCA3DReject->SetFillColor(kRed-2);
+ fQAProtonsRejectedList->Add(gProtonsDCA3DReject);
//========================================================//
fQAAntiProtonsAcceptedList = new TList();
fQAAntiProtonsAcceptedList->Add(gAntiProtonsPointOnITSLayer6Pass);
TH1F *gAntiProtonsNumberOfTPCdEdxPointsPass = new TH1F("gAntiProtonsNumberOfTPCdEdxPointsPass","",100,0,200);
fQAAntiProtonsAcceptedList->Add(gAntiProtonsNumberOfTPCdEdxPointsPass);
-
+ TH1F *gAntiProtonsITSClusterMapPass = new TH1F("gAntiProtonsITSClusterMapPass",";ITS Layer;Entries",6,0.5,6.5);
+ fQAAntiProtonsAcceptedList->Add(gAntiProtonsITSClusterMapPass);
+ TH1F *gAntiProtonsDCA3DPass = new TH1F("gAntiProtonsDCA3DPass",
+ ";dca [cm];Entries",
+ 100,0,20);
+ fQAAntiProtonsAcceptedList->Add(gAntiProtonsDCA3DPass);
+
//========================================================//
fQAAntiProtonsRejectedList = new TList();
fQAAntiProtonsRejectedList->SetName("fQAAntiProtonsRejectedList");
TH1F *gAntiProtonsNumberOfTPCdEdxPointsReject = new TH1F("gAntiProtonsNumberOfTPCdEdxPointsReject","",100,0,200);
gAntiProtonsNumberOfTPCdEdxPointsReject->SetFillColor(kRed-2);
fQAAntiProtonsRejectedList->Add(gAntiProtonsNumberOfTPCdEdxPointsReject);
+ TH1F *gAntiProtonsITSClusterMapReject = new TH1F("gAntiProtonsITSClusterMapReject",";ITS Layer;Entries",6,0.5,6.5);
+ gAntiProtonsITSClusterMapReject->SetFillColor(kRed-2);
+ fQAAntiProtonsRejectedList->Add(gAntiProtonsITSClusterMapReject);
+ TH1F *gAntiProtonsDCA3DReject = new TH1F("gAntiProtonsDCA3DReject",
+ ";dca [cm];Entries",
+ 100,0,20);
+ gAntiProtonsDCA3DReject->SetFillColor(kRed-2);
+ fQAAntiProtonsRejectedList->Add(gAntiProtonsDCA3DReject);
}
//____________________________________________________________________//
//Fills the QA histograms
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;
+ Float_t dcaXY = 0.0, dcaZ = 0.0;
+ if(!fProtonAnalysisBase) return;
if((fProtonAnalysisBase->GetAnalysisMode()==AliProtonAnalysisBase::kTPC)||(fProtonAnalysisBase->GetAnalysisMode()==AliProtonAnalysisBase::kHybrid)) {
AliExternalTrackParam *tpcTrack = (AliExternalTrackParam *)track->GetTPCInnerParam();
100.,dca,cov);
}
}
+ if(fProtonAnalysisBase->GetAnalysisMode()==AliProtonAnalysisBase::kFullHybrid) {
+ AliExternalTrackParam *tpcTrack = (AliExternalTrackParam *)track->GetTPCInnerParam();
+ AliExternalTrackParam cParam;
+ if(!tpcTrack) {
+ gPt = 0.0; gPx = 0.0; gPy = 0.0; gPz = 0.0;
+ dca[0] = -100.; dca[1] = -100.;
+ cov[0] = -100.; cov[1] = -100.; cov[2] = -100.;
+ }
+ else {
+ gPt = tpcTrack->Pt();
+ gPx = tpcTrack->Px();
+ gPy = tpcTrack->Py();
+ gPz = tpcTrack->Pz();
+ track->RelateToVertex(vertex,
+ esd->GetMagneticField(),
+ 100.,&cParam);
+ track->GetImpactParameters(dcaXY,dcaZ);
+ dca[0] = dcaXY; dca[1] = dcaZ;
+ }
+ }
else{
gPt = track->Pt();
gPx = track->Px();
100.,dca,cov);
}
- Int_t fIdxInt[200];
- Int_t nClustersITS = track->GetITSclusters(fIdxInt);
- Int_t nClustersTPC = track->GetTPCclusters(fIdxInt);
+ 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);
+ Int_t nClustersITS = track->GetITSclusters(0x0);
+ Int_t nClustersTPC = track->GetTPCclusters(0x0);
Float_t chi2PerClusterITS = -1;
if (nClustersITS!=0)
if(track->GetTPCsignalN() >= fProtonAnalysisBase->GetMinTPCdEdxPoints())
((TH1F *)(fQAProtonsAcceptedList->At(26)))->Fill(track->GetTPCsignalN());
}//number of TPC points for the dE/dx
+ if(fProtonAnalysisBase->IsUsedPointOnSPDLayer()) {
+ if((!track->HasPointOnITSLayer(0))&&(!track->HasPointOnITSLayer(1))) {
+ for(Int_t iLayer = 0; iLayer < 6; iLayer++) {
+ if(track->HasPointOnITSLayer(iLayer))
+ ((TH1F *)(fQAProtonsRejectedList->At(27)))->Fill(iLayer+1);
+ }
+ }
+ else if((track->HasPointOnITSLayer(0))||(track->HasPointOnITSLayer(1))) {
+ for(Int_t iLayer = 0; iLayer < 6; iLayer++) {
+ if(track->HasPointOnITSLayer(iLayer))
+ ((TH1F *)(fQAProtonsAcceptedList->At(27)))->Fill(iLayer+1);
+ }
+ }
+ }//point on either SPD layers
+ if(fProtonAnalysisBase->IsUsedMaxDCA3D()) {
+ if(dca3D > fProtonAnalysisBase->GetMaxDCA3D()) {
+ ((TH1F *)(fQAProtonsRejectedList->At(28)))->Fill(dca3D);
+ }
+ if(dca3D < fProtonAnalysisBase->GetMaxDCA3D())
+ ((TH1F *)(fQAProtonsAcceptedList->At(28)))->Fill(dca3D);
+ }//dca3D
}//protons
//antiprotons
if(track->GetTPCsignalN() >= fProtonAnalysisBase->GetMinTPCdEdxPoints())
((TH1F *)(fQAAntiProtonsAcceptedList->At(26)))->Fill(track->GetTPCsignalN());
}//number of TPC points for the dE/dx
+ if(fProtonAnalysisBase->IsUsedPointOnSPDLayer()) {
+ if((!track->HasPointOnITSLayer(0))&&(!track->HasPointOnITSLayer(1))) {
+ for(Int_t iLayer = 0; iLayer < 6; iLayer++) {
+ if(track->HasPointOnITSLayer(iLayer))
+ ((TH1F *)(fQAAntiProtonsRejectedList->At(27)))->Fill(iLayer+1);
+ }
+ }
+ else if((track->HasPointOnITSLayer(0))||(track->HasPointOnITSLayer(1))) {
+ for(Int_t iLayer = 0; iLayer < 6; iLayer++) {
+ if(track->HasPointOnITSLayer(iLayer))
+ ((TH1F *)(fQAAntiProtonsAcceptedList->At(27)))->Fill(iLayer+1);
+ }
+ }
+ }//point on either SPD layers
+ if(fProtonAnalysisBase->IsUsedMaxDCA3D()) {
+ if(dca3D > fProtonAnalysisBase->GetMaxDCA3D()) {
+ ((TH1F *)(fQAAntiProtonsRejectedList->At(28)))->Fill(dca3D);
+ }
+ if(dca3D < fProtonAnalysisBase->GetMaxDCA3D())
+ ((TH1F *)(fQAAntiProtonsAcceptedList->At(28)))->Fill(dca3D);
+ }//dca3D
}//antiprotons
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff