From 4ebdd20e07ab796e7c73d4a1a08b8162d6e1307b Mon Sep 17 00:00:00 2001 From: rpreghen Date: Fri, 11 May 2012 12:32:42 +0000 Subject: [PATCH] TPC rdEdx analysis code, macros and more (P.Christiansen) --- PWGLF/SPECTRA/IdentifiedHighPt/README.txt | 79 + .../corrected_fraction/corrected_fraction.C | 195 ++ .../corrected_fraction/syst_vs_pt.root | Bin 0 -> 6231 bytes .../efficiency/createEfficiency.C | 697 +++++ .../efficiency/lhc10d_eff_phojet.root | Bin 0 -> 68609 bytes .../efficiency/lhc10d_eff_pythia.root | Bin 0 -> 93004 bytes .../charged_spectra/dNdPt_pp_2.76TeV.root | Bin 0 -> 11697 bytes .../charged_spectra/dNdPt_pp_7TeV.root | Bin 0 -> 11765 bytes .../charged_spectra/dNdPt_pp_900GeV.root | Bin 0 -> 10959 bytes .../final_spectra/convertToMyBins.C | 343 +++ .../final_spectra/makeSpectra.C | 112 + .../IdentifiedHighPt/grid/AddTaskHighPtDeDx.C | 185 ++ .../grid/AddTaskHighPtDeDxV0.C | 190 ++ .../grid/AliAnalysisTaskHighPtDeDx.cxx | 1705 +++++++++++ .../grid/AliAnalysisTaskHighPtDeDx.h | 141 + .../grid/AliAnalysisTaskHighPtDeDxV0.cxx | 2499 +++++++++++++++++ .../grid/AliAnalysisTaskHighPtDeDxV0.h | 139 + .../grid/CreateAlienHandler.C | 204 ++ .../IdentifiedHighPt/grid/DebugClasses.C | 242 ++ .../IdentifiedHighPt/grid/DebugClasses_C.d | 4 + .../grid/HighPtDeDx_lhc10b_Data_ESDs_merge.C | 94 + .../grid/HighPtDeDx_lhc10c_Data_ESDs_merge.C | 94 + .../IdentifiedHighPt/grid/ListDirectories.h | 51 + .../grid/copyStatisticFiles.C | 115 + .../SPECTRA/IdentifiedHighPt/grid/lhc10b.conf | 35 + .../grid/macro_HighPtDeDx_lhc10b_Data_ESDs.C | 107 + PWGLF/SPECTRA/IdentifiedHighPt/grid/runAAF.C | 655 +++++ .../IdentifiedHighPt/grid/test_esd.txt | 1 + .../lib/AliHighPtDeDxBase.cxx | 487 ++++ .../IdentifiedHighPt/lib/AliHighPtDeDxBase.h | 133 + .../lib/AliHighPtDeDxBaseCint.h | 72 + .../lib/AliHighPtDeDxCalib.cxx | 871 ++++++ .../IdentifiedHighPt/lib/AliHighPtDeDxCalib.h | 132 + .../lib/AliHighPtDeDxData.cxx | 483 ++++ .../IdentifiedHighPt/lib/AliHighPtDeDxData.h | 79 + .../IdentifiedHighPt/lib/AliHighPtDeDxMc.cxx | 359 +++ .../IdentifiedHighPt/lib/AliHighPtDeDxMc.h | 59 + .../lib/AliHighPtDeDxSpectra.cxx | 285 ++ .../lib/AliHighPtDeDxSpectra.h | 69 + PWGLF/SPECTRA/IdentifiedHighPt/lib/Include.h | 20 + PWGLF/SPECTRA/IdentifiedHighPt/lib/LinkDef.h | 13 + PWGLF/SPECTRA/IdentifiedHighPt/lib/Makefile | 100 + .../IdentifiedHighPt/macros/calibrate_de_dx.C | 1202 ++++++++ .../IdentifiedHighPt/macros/drawText.C | 12 + .../IdentifiedHighPt/macros/draw_separation.C | 163 ++ .../macros/fit_yields_final.C | 1372 +++++++++ .../IdentifiedHighPt/macros/fit_yields_old.C | 1459 ++++++++++ .../IdentifiedHighPt/macros/my_functions.C | 259 ++ .../IdentifiedHighPt/macros/my_tools.C | 198 ++ .../IdentifiedHighPt/macros/run_code.C | 1501 ++++++++++ 50 files changed, 17215 insertions(+) create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/README.txt create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/corrected_fraction/corrected_fraction.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/corrected_fraction/syst_vs_pt.root create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/efficiency/createEfficiency.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/efficiency/lhc10d_eff_phojet.root create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/efficiency/lhc10d_eff_pythia.root create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/final_spectra/charged_spectra/dNdPt_pp_2.76TeV.root create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/final_spectra/charged_spectra/dNdPt_pp_7TeV.root create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/final_spectra/charged_spectra/dNdPt_pp_900GeV.root create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/final_spectra/convertToMyBins.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/final_spectra/makeSpectra.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/AddTaskHighPtDeDx.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/AddTaskHighPtDeDxV0.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/AliAnalysisTaskHighPtDeDx.cxx create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/AliAnalysisTaskHighPtDeDx.h create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/AliAnalysisTaskHighPtDeDxV0.cxx create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/AliAnalysisTaskHighPtDeDxV0.h create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/CreateAlienHandler.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/DebugClasses.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/DebugClasses_C.d create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/HighPtDeDx_lhc10b_Data_ESDs_merge.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/HighPtDeDx_lhc10c_Data_ESDs_merge.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/ListDirectories.h create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/copyStatisticFiles.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/lhc10b.conf create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/macro_HighPtDeDx_lhc10b_Data_ESDs.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/runAAF.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/grid/test_esd.txt create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/lib/AliHighPtDeDxBase.cxx create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/lib/AliHighPtDeDxBase.h create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/lib/AliHighPtDeDxBaseCint.h create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/lib/AliHighPtDeDxCalib.cxx create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/lib/AliHighPtDeDxCalib.h create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/lib/AliHighPtDeDxData.cxx create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/lib/AliHighPtDeDxData.h create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/lib/AliHighPtDeDxMc.cxx create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/lib/AliHighPtDeDxMc.h create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/lib/AliHighPtDeDxSpectra.cxx create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/lib/AliHighPtDeDxSpectra.h create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/lib/Include.h create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/lib/LinkDef.h create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/lib/Makefile create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/macros/calibrate_de_dx.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/macros/drawText.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/macros/draw_separation.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/macros/fit_yields_final.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/macros/fit_yields_old.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/macros/my_functions.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/macros/my_tools.C create mode 100644 PWGLF/SPECTRA/IdentifiedHighPt/macros/run_code.C diff --git a/PWGLF/SPECTRA/IdentifiedHighPt/README.txt b/PWGLF/SPECTRA/IdentifiedHighPt/README.txt new file mode 100644 index 00000000000..25adb1ee008 --- /dev/null +++ b/PWGLF/SPECTRA/IdentifiedHighPt/README.txt @@ -0,0 +1,79 @@ +The idea is to document the different steps needed to make spectra. + +STEP 1: GRID CODE +================= + +In the directory grid you will find the code used to produce the trees. For +info on how to use have a look at runAAF.C + +STEP 2: EXTRACT TREES +===================== + +The file produced on the grid contains the trees in the list. This means that +one cannot direcrtly chain tghem. Therefore we use the code in extract_code to +make new files with the trees only. + +Example: +./merge.sh aortizve/Trees_LHC10b_Pass3/files/ +and +./merge.sh aortizve/Trees_LHC10b_Pass3/files/ HighPtDeDxV0 + +STEP 3: COMPILE LIBRARY +======================= + +cd lib +make clean +make + + +STEP 4: DETERMINE RATIOS +======================== + +This is the biggest step. + +mkdir ratios_7tevb +cd ratios_7tevb + +First we need to create the text files we want to analyze. +Example: +find /home/pchristi/work/analysis/7tev/ | grep HighPtDeDx_Tree | grep new | grep 117059 > 7tev_b_test.dat +find /home/pchristi/work/analysis/7tev/ | grep HighPtDeDx_Tree | grep new > 7tev_b.dat + +find /home/pchristi/work/analysis/7tev/ | grep HighPtDeDxV0_Tree | grep new | grep 117059 > 7tev_b_test_v0.dat +find /home/pchristi/work/analysis/7tev/ | grep HighPtDeDxV0_Tree | grep new > 7tev_b_v0.dat + +ln -s ../macros/run_code.C . +ln -s ../macros/calibrate_de_dx.C . + +cp ../macros/drawText.C . +Edit the text here. This macro is used to tag the pictures. + +Follow the example in the macro run_code.C + +Step 1-5 is about determining the dE/dx calibrations and the input data to the +fits in pT. + +Now it is time for extracting the uncorrected ratios. + +ln -s ../macros/fit_yields_final.C . + +This is documented in fit_yields_final.C + + +There is still things missing: +- Option to generate tree when generating the data. +- The code to estimate systematic errors +- Efficiency code +- Corrected fractions +- Spectra and RAA code + +But that will come soon - hopefully next week. + + + + +To zip: + +ls -1 README.txt lib/Makefile lib/*.cxx lib/*.h macros/*.C > tozip.txt +tar -hcvzf analysis.tgz -T tozip.txt + diff --git a/PWGLF/SPECTRA/IdentifiedHighPt/corrected_fraction/corrected_fraction.C b/PWGLF/SPECTRA/IdentifiedHighPt/corrected_fraction/corrected_fraction.C new file mode 100644 index 00000000000..ef070b3efb7 --- /dev/null +++ b/PWGLF/SPECTRA/IdentifiedHighPt/corrected_fraction/corrected_fraction.C @@ -0,0 +1,195 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "my_tools.C" + + +/* + Info: + * Efficiencies are currently set by hand!!!!! + * Systematic errors needs an update also. + * Need to accomodate k+p at soem point! + + To run: + + gSystem->AddIncludePath("-I../macros") + gSystem->AddIncludePath("-I../lib") + gROOT->SetMacroPath(".:../macros") + .L my_tools.C++ + .L corrected_fraction.C+ + + + CorrectedFraction("../ratios_7tevb/fit_yields_results/7tev_b.root", "fraction_7tev_b_pi.root", 1, "PP", 0, 10.0); + CorrectedFraction("../ratios_7tevb/fit_yields_results/7tev_b.root", "fraction_7tev_b_k.root", 2, "PP", 0, 10.0); + CorrectedFraction("../ratios_7tevb/fit_yields_results/7tev_b.root", "fraction_7tev_b_p.root", 3, "PP", 0, 10.0); + + + And in the shell one can add files like: + + hadd fraction_7tev_b_all.root fraction_7tev_b_pi.root fraction_7tev_b_k.root fraction_7tev_b_p.root + + */ + +void CorrectedFraction(const Char_t* inFileName, const Char_t* outFileName, Int_t pid, + const Char_t* endName="PP", Int_t centBin=0, + Double_t ptMax=20.0, const Char_t* outDir="plots"); +TH1D* GetSystErrorHist(TH1D* hRatio, Int_t centBin, TF1* electronFraction); + + +//________________________________________________________________________________________ +void CorrectedFraction(const Char_t* inFileName, const Char_t* outFileName, Int_t pid, + const Char_t* endName, Int_t centBin, + Double_t ptMax, const Char_t* outDir) +{ + gStyle->SetOptStat(0); + + + TFile* fileData = FindFileFresh(inFileName); + + if(!fileData) + return; + + TF1* fElectronFraction = (TF1*)fileData->Get("fElectronFraction"); + cout << "Electron fraction found!" << endl; + TH1D* hPionRatio = 0; + if(pid==1) { + hPionRatio = (TH1D*)fileData->Get("hPionRatio"); + CutHistogram(hPionRatio, 2.0, ptMax); + hPionRatio->SetMarkerStyle(24); + } else if(pid==2) { + hPionRatio = (TH1D*)fileData->Get("hKaonRatio"); + CutHistogram(hPionRatio, 3.0, ptMax); + hPionRatio->SetMarkerStyle(25); + } else if(pid==3) { + hPionRatio = (TH1D*)fileData->Get("hProtonRatio"); + CutHistogram(hPionRatio, 3.0, ptMax); + hPionRatio->SetMarkerStyle(25); + } + + // Global variable + TH1D* hSystFraction = 0; + if(pid==1) + hSystFraction = GetSystErrorHist(hPionRatio, centBin, fElectronFraction); + else + hSystFraction = GetSystErrorHist(hPionRatio, centBin, 0); + hSystFraction->SetLineColor(1); + hSystFraction->SetMarkerStyle(1); + hSystFraction->SetFillStyle(1001); + hSystFraction->SetFillColor(kGray); + + TH1D* hPionFraction = (TH1D*)hPionRatio->Clone("hPionFraction"); + if(pid==1 && !fElectronFraction) { + TF1 f1("f1", "1.0", 0.0, 50.0); + cout << "NO ELECTRON FRACTION!!!" << endl; + hPionFraction->Add(&f1, -0.01); // correct for muons and electrons + CutHistogram(hPionFraction, 3.0, ptMax); + hSystFraction->Add(&f1, -0.01); // correct for muons and electrons + CutHistogram(hSystFraction, 3.0, ptMax); + } + + if(pid==1 || pid ==3) { + + hPionFraction->Scale(0.94); // correct for efficiency ratio + hSystFraction->Scale(0.94); // correct for efficiency ratio + } else { + + TF1* effRatioK = new TF1("effRatioK", "exp(-[1]*x)+[0]", 0.0, 50.0); + effRatioK->SetParameters(9.82065e-01, 1.28157e+00); + hPionFraction->Multiply(effRatioK); // correct for efficiency ratio + hSystFraction->Multiply(effRatioK); // correct for efficiency ratio + } + + if(pid==1) + hPionFraction->SetMarkerStyle(20); + else + hPionFraction->SetMarkerStyle(20); + TLatex latex; + latex.SetNDC(); + latex.SetTextSize(0.05); + + TCanvas* cRatios = new TCanvas("cRatios", "Particle fractions"); + cRatios->Clear(); + hSystFraction->GetXaxis()->SetRangeUser(0, ptMax); + hSystFraction->GetYaxis()->SetRangeUser(0, 1); + hSystFraction->Draw("E5"); + hPionRatio->Draw("SAME"); + hPionFraction->Draw("SAME"); + latex.DrawLatex(0.6, 0.95, Form("%s", endName)); + + CreateDir(outDir); + if(pid==1) { + hPionFraction->SetName(Form("hPionFraction_%s", endName)); + hSystFraction->SetName(Form("hPionFractionSyst_%s", endName)); + cRatios->SaveAs(Form("%s/fractions_%s_pions.gif", outDir, endName)); + } else if (pid==2) { + hPionFraction->SetName(Form("hKaonFraction_%s", endName)); + hSystFraction->SetName(Form("hKaonFractionSyst_%s", endName)); + cRatios->SaveAs(Form("%s/fractions_%s_kaons.gif", outDir, endName)); + } else if (pid==3) { + hPionFraction->SetName(Form("hProtonFraction_%s", endName)); + hSystFraction->SetName(Form("hProtonFractionSyst_%s", endName)); + cRatios->SaveAs(Form("%s/fractions_%s_protons.gif", outDir, endName)); + } + + TFile* outFile = new TFile(outFileName, "RECREATE"); + hPionFraction->Write(); + hSystFraction->Write(); + outFile->Close(); +} + +//__________________________________________________________________________________ +TH1D* GetSystErrorHist(TH1D* hRatio, Int_t centBin, TF1* electronFraction) +{ + TFile* fileSyst = FindFile("syst_vs_pt.root"); + + TF1* fSyst = (TF1*)fileSyst->Get(Form("systHigh%d", centBin)); + fSyst->SetRange(2.0, 20.0); + fSyst->Print(); + + Double_t syst_error_mc = 0.03; // pp + if (centBin>0) + syst_error_mc = 0.05; // Pb+Pb + + Double_t syst_error_correction = 0.01; // pp + if (centBin>0) + syst_error_correction = 0.03; // Pb+Pb + + TH1D* hSystError = (TH1D*)hRatio->Clone("hPionFractionSyst"); + hSystError->Multiply(fSyst); + + const Int_t nBins = hSystError->GetNbinsX(); + for(Int_t bin = 1; bin <= nBins; bin++) { + + Double_t value = hRatio->GetBinContent(bin); + Double_t stat_error = hSystError->GetBinContent(bin); + + if(value==0) + continue; + + Double_t syst_error = stat_error*stat_error; + syst_error += value*value*syst_error_mc*syst_error_mc; + syst_error += value*value*syst_error_correction*syst_error_correction; + + + if (electronFraction) { + + Double_t systEandMu = electronFraction->Eval(hRatio->GetXaxis()->GetBinCenter(bin)); + syst_error += systEandMu*systEandMu; + } + + syst_error = TMath::Sqrt(syst_error); + hSystError->SetBinContent(bin, value); + hSystError->SetBinError(bin, syst_error); + } + + return hSystError; +} + diff --git a/PWGLF/SPECTRA/IdentifiedHighPt/corrected_fraction/syst_vs_pt.root b/PWGLF/SPECTRA/IdentifiedHighPt/corrected_fraction/syst_vs_pt.root new file mode 100644 index 0000000000000000000000000000000000000000..bbfe6dab3939d7ee6925d3fb53a5abf946183141 GIT binary patch literal 6231 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 literal 0 HcmV?d00001 diff --git a/PWGLF/SPECTRA/IdentifiedHighPt/efficiency/createEfficiency.C b/PWGLF/SPECTRA/IdentifiedHighPt/efficiency/createEfficiency.C new file mode 100644 index 00000000000..1b48ea74cb9 --- /dev/null +++ b/PWGLF/SPECTRA/IdentifiedHighPt/efficiency/createEfficiency.C @@ -0,0 +1,697 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "DebugClasses.C" +#include "my_tools.C" + +#include + +using namespace std; + +/* + To run code: + ============ + + Info: + * I did not recheck this code. For now I would just use the efficiency values I have. + * The code could be made nicer. Esepcially some plots could be put in folders. + + Use AliRoot because of AliXRDPROOFtoolkit: + gSystem->AddIncludePath("-I$ALICE_ROOT/TPC") + gSystem->AddIncludePath("-I../lib") + gSystem->AddIncludePath("-I../grid") + gSystem->AddIncludePath("-I../macros") + gROOT->SetMacroPath(".:../macros:../grid:../lib/") + .L my_tools.C+ + .L DebugClasses.C+ + .L createEfficiency.C+ + + Examples of visualization: + DrawEfficiency("lhc10d_eff_pythia.root", "eff.root") + + // This is the correction I did for the low pT guys + DrawCorrection("lhc10d_eff_pythia.root", "lhc10d_eff_phojet.root") + + + + CreateEff("lhc10d_mc_all.dat", 0, "lhc10d_eff_all.root") + + +*/ + +void DrawEfficiency(const Char_t* fileName, const Char_t* effFileName); +void DrawCorrection(const Char_t* fileNamePYTHIA, const Char_t* fileNamePHOJET); +TH1D* HistInvert(TH1D* hist); + + +void CreateEff(const Char_t* mcFileName, Int_t maxEvents, const Char_t* mcOutFileName, + Float_t centLow=-20, Float_t centHigh=-5) +{ + gStyle->SetOptStat(0); + // + // Create output + // + TFile* outFile = new TFile(mcOutFileName, "RECREATE"); + + const Int_t nPid = 7; + TH1D* hMcIn[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hMcOut[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hMcSec[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hMcEff[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hMcInNeg[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hMcOutNeg[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hMcSecNeg[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hMcEffNeg[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hMcInPos[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hMcOutPos[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hMcSecPos[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hMcEffPos[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + + Int_t color[nPid] = {1, 2, 3, 4, 5, 1, 1}; + + const Int_t nPtBins = 68; + Double_t xBins[nPtBins+1] = {0. , 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, + 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, + 1.0, 1.1 , 1.2, 1.3 , 1.4, 1.5 , 1.6, 1.7 , 1.8, 1.9 , + 2.0, 2.2 , 2.4, 2.6 , 2.8, 3.0 , 3.2, 3.4 , 3.6, 3.8 , + 4.0, 4.5 , 5.0, 5.5 , 6.0, 6.5 , 7.0, 8.0 , 9.0, 10.0, + 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 18.0, 20.0, 22.0, 24.0, + 26.0, 28.0, 30.0, 32.0, 34.0, 36.0, 40.0, 45.0, 50.0 }; + + for(Int_t pid = 0; pid < nPid; pid++) { + + hMcIn[pid] = new TH1D(Form("hIn%d", pid), Form("Efficiency (pid %d)", pid), + nPtBins, xBins); + hMcInNeg[pid] = new TH1D(Form("hInNeg%d", pid), Form("Efficiency (pid %d, q < 0)", pid), + nPtBins, xBins); + hMcInPos[pid] = new TH1D(Form("hInPos%d", pid), Form("Efficiency (pid %d, q < 0)", pid), + nPtBins, xBins); + + hMcIn[pid]->Sumw2(); + hMcIn[pid]->SetMarkerStyle(29); + hMcIn[pid]->SetMarkerColor(color[pid]); + hMcInNeg[pid]->Sumw2(); + hMcInNeg[pid]->SetMarkerStyle(24); + hMcInNeg[pid]->SetMarkerColor(color[pid]); + hMcInPos[pid]->Sumw2(); + hMcInPos[pid]->SetMarkerStyle(20); + hMcInPos[pid]->SetMarkerColor(color[pid]); + + hMcOut[pid] = new TH1D(Form("hMcOut%d", pid), Form("MC out (pid %d)", pid), + nPtBins, xBins); + hMcOutNeg[pid] = new TH1D(Form("hMcOutNeg%d", pid), Form("MC out (pid %d, q < 0)", pid), + nPtBins, xBins); + hMcOutPos[pid] = new TH1D(Form("hMcOutPos%d", pid), Form("MC out (pid %d, q < 0)", pid), + nPtBins, xBins); + + hMcOut[pid]->Sumw2(); + hMcOut[pid]->SetMarkerStyle(29); + hMcOut[pid]->SetMarkerColor(color[pid]); + hMcOutNeg[pid]->Sumw2(); + hMcOutNeg[pid]->SetMarkerStyle(24); + hMcOutNeg[pid]->SetMarkerColor(color[pid]); + hMcOutPos[pid]->Sumw2(); + hMcOutPos[pid]->SetMarkerStyle(20); + hMcOutPos[pid]->SetMarkerColor(color[pid]); + + hMcSec[pid] = new TH1D(Form("hSec%d", pid), Form("Secondaries (pid %d)", pid), + nPtBins, xBins); + hMcSecNeg[pid] = new TH1D(Form("hSecNeg%d", pid), Form("Secondaries (pid %d, q < 0)", pid), + nPtBins, xBins); + hMcSecPos[pid] = new TH1D(Form("hSecPos%d", pid), Form("Secondaries (pid %d, q < 0)", pid), + nPtBins, xBins); + + hMcSec[pid]->Sumw2(); + hMcSec[pid]->SetMarkerStyle(29); + hMcSec[pid]->SetMarkerColor(color[pid]); + hMcSecNeg[pid]->Sumw2(); + hMcSecNeg[pid]->SetMarkerStyle(24); + hMcSecNeg[pid]->SetMarkerColor(color[pid]); + hMcSecPos[pid]->Sumw2(); + hMcSecPos[pid]->SetMarkerStyle(20); + hMcSecPos[pid]->SetMarkerColor(color[pid]); + + hMcEff[pid] = new TH1D(Form("hEff%d", pid), Form("Efficiency (pid %d)", pid), + nPtBins, xBins); + hMcEffNeg[pid] = new TH1D(Form("hEffNeg%d", pid), Form("Efficiency (pid %d, q < 0)", pid), + nPtBins, xBins); + hMcEffPos[pid] = new TH1D(Form("hEffPos%d", pid), Form("Efficiency (pid %d, q < 0)", pid), + nPtBins, xBins); + + hMcEff[pid]->Sumw2(); + hMcEff[pid]->SetMarkerStyle(29); + hMcEff[pid]->SetMarkerColor(color[pid]); + hMcEffNeg[pid]->Sumw2(); + hMcEffNeg[pid]->SetMarkerStyle(24); + hMcEffNeg[pid]->SetMarkerColor(color[pid]); + hMcEffPos[pid]->Sumw2(); + hMcEffPos[pid]->SetMarkerStyle(20); + hMcEffPos[pid]->SetMarkerColor(color[pid]); + } + + TTree* Tree = 0; + if(strstr(mcFileName, ".dat")) { + + AliXRDPROOFtoolkit tool; + TChain* chain = tool.MakeChain(mcFileName,"tree", 0, 1000); + chain->Lookup(); + Tree = chain; + } else { + TFile* mcFile = FindFileFresh(mcFileName); + if(!mcFile) + return; + + Tree = (TTree*)mcFile->Get("tree"); + } + if(!Tree) + return; + + + DeDxEvent* event = 0; + TClonesArray* trackArray = 0; + TClonesArray* mcTrackArray = 0; + Tree->SetBranchAddress("event", &event); + Tree->SetBranchAddress("track" , &trackArray); + Tree->SetBranchAddress("trackMC" , &mcTrackArray); + Int_t nEvents = Tree->GetEntries(); + cout << "Number of events: " << nEvents << endl; + + if(maxEvents>0 && maxEvents < nEvents) { + + nEvents = maxEvents; + cout << "N events was reduced to: " << maxEvents << endl; + } + + Int_t currentRun = 0; + + for(Int_t n = 0; n < nEvents; n++) { + + Tree->GetEntry(n); + + if((n+1)%1000000==0) + cout << "Event: " << n+1 << "/" << nEvents << endl; + + if(event->run != currentRun) { + + cout << "New run: " << event->run << endl; + currentRun = event->run; + } + + if(event->cent < centLow || event->cent > centHigh) + continue; + + const Int_t nMcTracks = mcTrackArray->GetEntries(); + + for(Int_t i = 0; i < nMcTracks; i++) { + + DeDxTrackMC* trackMC = (DeDxTrackMC*)mcTrackArray->At(i); + + // if(TMath::Abs(trackMC->pdgMC)==3312 || TMath::Abs(trackMC->pdgMC)==3334) + // continue; // Xi-! + + hMcIn[0]->Fill(trackMC->ptMC); + hMcIn[trackMC->pidMC]->Fill(trackMC->ptMC); + + if(trackMC->qMC < 0) { + + hMcInNeg[0]->Fill(trackMC->ptMC); + hMcInNeg[trackMC->pidMC]->Fill(trackMC->ptMC); + } else { + + hMcInPos[0]->Fill(trackMC->ptMC); + hMcInPos[trackMC->pidMC]->Fill(trackMC->ptMC); + } + } + + const Int_t nTracks = trackArray->GetEntries(); + + for(Int_t i = 0; i < nTracks; i++) { + + DeDxTrack* track = (DeDxTrack*)trackArray->At(i); + + if(!(track->filter&1)) + continue; + + // if(TMath::Abs(track->mother)==3312 || TMath::Abs(track->mother)==3334) + // continue; // Xi+- or Omega+-! + + hMcOut[0]->Fill(track->pt); + hMcOut[track->pid]->Fill(track->pt); + + if(track->q < 0) { + + hMcOutNeg[0]->Fill(track->pt); + hMcOutNeg[track->pid]->Fill(track->pt); + } else { + + hMcOutPos[0]->Fill(track->pt); + hMcOutPos[track->pid]->Fill(track->pt); + } + + if(track->primary==0) { + hMcSec[0]->Fill(track->pt); + hMcSec[track->pid]->Fill(track->pt); + + if(track->q < 0) { + + hMcSecNeg[0]->Fill(track->pt); + hMcSecNeg[track->pid]->Fill(track->pt); + } else { + + hMcSecPos[0]->Fill(track->pt); + hMcSecPos[track->pid]->Fill(track->pt); + } + } + } + } + + TH1D* hMcInPiKP = (TH1D*)hMcIn[1]->Clone("hMcInPiKP"); + hMcInPiKP->Add(hMcIn[2]); + hMcInPiKP->Add(hMcIn[3]); + hMcInPiKP->Divide(hMcIn[0]); + + for(Int_t pid = 0; pid < nPid; pid++) { + + hMcSec[pid]->Divide(hMcSec[pid], hMcOut[pid]); + hMcSecNeg[pid]->Divide(hMcSecNeg[pid], hMcOutNeg[pid]); + hMcSecPos[pid]->Divide(hMcSecPos[pid], hMcOutPos[pid]); + + hMcEff[pid] ->Divide(hMcOut[pid], hMcIn[pid]); + hMcEffNeg[pid]->Divide(hMcOutNeg[pid], hMcInNeg[pid]); + hMcEffPos[pid]->Divide(hMcOutPos[pid], hMcInPos[pid]); + } + + outFile->Write(); + outFile->Close(); +} + +//_______________________________________________________________________ +void DrawEfficiency(const Char_t* fileName, const Char_t* effFileName) +{ + TFile* file = FindFileFresh(fileName); + if(!file) + return; + + gStyle->SetOptStat(0); + + const Double_t ptmin = 3.01; + const Double_t ptmax = 19.999; + // const Double_t ptmax = 49.999; + + const Double_t effmin = 0.6; + const Double_t effmax = 0.9; + + // const Double_t effmin = 0.0; + // const Double_t effmax = 1.5; + + const Double_t secmin = 0.0; + const Double_t secmax = 0.1; + + const Int_t nPid = 7; + + TH1D* hEff[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hEffNeg[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hEffPos[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hSec[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hSecNeg[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hSecPos[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hOut[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + + for(Int_t pid = 0; pid < nPid; pid++) { + + hEff[pid] = (TH1D*)file->Get(Form("hEff%d", pid)); + + hEffNeg[pid] = (TH1D*)file->Get(Form("hEffNeg%d", pid)); + + hEffPos[pid] = (TH1D*)file->Get(Form("hEffPos%d", pid)); + + hSec[pid] = (TH1D*)file->Get(Form("hSec%d", pid)); + + hSecNeg[pid] = (TH1D*)file->Get(Form("hSecNeg%d", pid)); + + hSecPos[pid] = (TH1D*)file->Get(Form("hSecPos%d", pid)); + + hOut[pid] = (TH1D*)file->Get(Form("hMcOut%d", pid)); + + // hEff[pid]->Rebin(4); + // hEffNeg[pid]->Rebin(4); + // hEffPos[pid]->Rebin(4); + + // hSec[pid]->Rebin(4); + // hSecNeg[pid]->Rebin(4); + // hSecPos[pid]->Rebin(4); + + // hOut[pid]->Rebin(4); + + // hEff[pid]->Scale(0.25); + // hEffNeg[pid]->Scale(0.25); + // hEffPos[pid]->Scale(0.25); + + // hSec[pid]->Scale(0.25); + // hSecNeg[pid]->Scale(0.25); + // hSecPos[pid]->Scale(0.25); + + // hOut[pid]->Scale(0.25); + + hEff[pid]->GetXaxis()->SetRangeUser(ptmin, ptmax); + hEff[pid]->GetYaxis()->SetRangeUser(effmin, effmax); + hEffNeg[pid]->GetXaxis()->SetRangeUser(ptmin, ptmax); + hEffNeg[pid]->GetYaxis()->SetRangeUser(effmin, effmax); + hEffPos[pid]->GetXaxis()->SetRangeUser(ptmin, ptmax); + hEffPos[pid]->GetYaxis()->SetRangeUser(effmin, effmax); + hSec[pid]->GetXaxis()->SetRangeUser(ptmin, ptmax); + hSec[pid]->GetYaxis()->SetRangeUser(secmin, secmax); + hSecNeg[pid]->GetXaxis()->SetRangeUser(ptmin, ptmax); + hSecNeg[pid]->GetYaxis()->SetRangeUser(secmin, secmax); + hSecPos[pid]->GetXaxis()->SetRangeUser(ptmin, ptmax); + hSecPos[pid]->GetYaxis()->SetRangeUser(secmin, secmax); + hOut[pid]->GetXaxis()->SetRangeUser(ptmin, ptmax); + } + + TCanvas* cChEff = new TCanvas("cChEff", "All efficiency", 800, 300); + cChEff->Clear(); + cChEff->Divide(2, 1); + cChEff->cd(1); + // TF1* pionEff = new TF1("pionEff", "pol0", 0.0, 50.0); + TF1* chEff = new TF1("chEff", "[0]*(1-[1]/x)", 0.0, 50.0); + chEff->SetLineColor(1); + chEff->SetParameters(0.7, 0.5); + hEff[0]->Fit(chEff, "", "", ptmin, ptmax); + + cChEff->cd(2); + hEffPos[0]->Draw(); + hEffNeg[0]->Draw("SAME"); + chEff->DrawCopy("SAME"); + cChEff->SaveAs("eff_charged.gif"); + + TCanvas* cPionEff = new TCanvas("cPionEff", "Pion efficiency", 800, 300); + cPionEff->Clear(); + cPionEff->Divide(2, 1); + cPionEff->cd(1); + // TF1* pionEff = new TF1("pionEff", "pol0", 0.0, 50.0); + TF1* pionEff = new TF1("pionEff", "[0]*(1-[1]/x)", 0.0, 50.0); + pionEff->SetLineColor(2); + pionEff->SetParameters(0.7, 0.5); + hEff[1]->Fit(pionEff, "", "", ptmin, ptmax); + + cPionEff->cd(2); + hEffPos[1]->Draw(); + hEffNeg[1]->Draw("SAME"); + pionEff->DrawCopy("SAME"); + cPionEff->SaveAs("eff_pion.gif"); + + TCanvas* cKaonEff = new TCanvas("cKaonEff", "Kaon efficiency", 800, 300); + cKaonEff->Clear(); + cKaonEff->Divide(2, 1); + cKaonEff->cd(1); + // TF1* kaonEff = new TF1("kaonEff", "pol0", 0.0, 50.0); + TF1* kaonEff = new TF1("kaonEff", "[0]*(1-[1]/x)", 0.0, 50.0); + kaonEff->SetLineColor(3); + kaonEff->SetParameters(0.7, 0.5); + hEff[2]->Fit(kaonEff, "", "", ptmin, ptmax); + + cKaonEff->cd(2); + hEffPos[2]->Draw(); + hEffNeg[2]->Draw("SAME"); + kaonEff->DrawCopy("SAME"); + cKaonEff->SaveAs("eff_kaon.gif"); + + TCanvas* cProtonEff = new TCanvas("cProtonEff", "Proton efficiency", 800, 300); + cProtonEff->Clear(); + cProtonEff->Divide(2, 1); + cProtonEff->cd(1); + // TF1* protonEff = new TF1("protonEff", "pol0", 0.0, 50.0); + TF1* protonEff = new TF1("protonEff", "[0]*(1-[1]/x)", 0.0, 50.0); + protonEff->SetLineColor(4); + protonEff->SetParameters(0.7, 0.5); + hEff[3]->Fit(protonEff, "", "", ptmin, ptmax); + + cProtonEff->cd(2); + hEffPos[3]->Draw(); + hEffNeg[3]->Draw("SAME"); + protonEff->DrawCopy("SAME"); + cProtonEff->SaveAs("eff_proton.gif"); + + TCanvas* cAllEff = new TCanvas("cAllEff", "All efficiency", 400, 300); + cAllEff->Clear(); + + TH1D* hDummy = (TH1D*)hEff[1]->Clone("hDummy"); + hDummy->Reset(); + hDummy->SetTitle("Efficiency vs p_{T}; p_{T} [GeV/c]; Efficiency"); + hDummy->Draw(); + + chEff->DrawCopy("SAME"); + pionEff->DrawCopy("SAME"); + kaonEff->DrawCopy("SAME"); + protonEff->DrawCopy("SAME"); + cAllEff->SaveAs("eff_all.gif"); + + // TCanvas* cPionSec = new TCanvas("cPionSec", "Pion sec", 800, 300); + // cPionSec->Clear(); + // cPionSec->Divide(2, 1); + // cPionSec->cd(1); + // TF1* pionSec = new TF1("pionSec", "pol0", 0.0, 50.0); + // hSec[1]->Fit(pionSec, "", "", ptmin, ptmax); + + // cPionSec->cd(2); + // hSecPos[1]->Draw(); + // hSecNeg[1]->Draw("SAME"); + // pionSec->Draw("SAME"); + // cPionSec->SaveAs("sec_pion.gif"); + + // TCanvas* cKaonSec = new TCanvas("cKaonSec", "Kaon sec", 800, 300); + // cKaonSec->Clear(); + // cKaonSec->Divide(2, 1); + // cKaonSec->cd(1); + // TF1* kaonSec = new TF1("kaonSec", "pol0", 0.0, 50.0); + // hSec[2]->Fit(kaonSec, "", "", ptmin, ptmax); + + // cKaonSec->cd(2); + // hSecPos[2]->Draw(); + // hSecNeg[2]->Draw("SAME"); + // kaonSec->Draw("SAME"); + // cKaonSec->SaveAs("sec_kaon.gif"); + + // TCanvas* cProtonSec = new TCanvas("cProtonSec", "Proton sec", 800, 300); + // cProtonSec->Clear(); + // cProtonSec->Divide(2, 1); + // cProtonSec->cd(1); + // TF1* protonSec = new TF1("protonSec", "pol0", 0.0, 50.0); + // hSec[3]->Fit(protonSec, "", "", ptmin, ptmax); + + // cProtonSec->cd(2); + // hSecPos[3]->Draw(); + // hSecNeg[3]->Draw("SAME"); + // protonSec->Draw("SAME"); + // cProtonSec->SaveAs("sec_proton.gif"); + + + TCanvas* cEffRatioPi = new TCanvas("cEffRatioPi", "eff pi / eff all", 400, 300); + cEffRatioPi->Clear(); + // TF1* pionEff = new TF1("pionEff", "pol0", 0.0, 50.0); + TF1* effRatioPi = new TF1("effRatioPi", "pol0", 0.0, 50.0); + effRatioPi->SetLineColor(6); + effRatioPi->SetParameters(0.7, 0.5); + TH1D* hEffRatioPi = (TH1D*)hEff[1]->Clone("hEffRatioPi"); + hEffRatioPi->SetTitle("; p_{T} [GeV/c]; #epsilon_{ch}/#epsilon_{pi}"); + hEffRatioPi->Divide(hEff[0], hEff[1], 1, 1, "B"); + // hEffRatioPi->Divide(hEff[1], hEff[0]); + hEffRatioPi->GetXaxis()->SetRangeUser(0.0, 19.99); + hEffRatioPi->GetYaxis()->SetRangeUser(0.8, 1.1); + hEffRatioPi->SetStats(kTRUE); + hEffRatioPi->Fit(effRatioPi, "", "", ptmin, ptmax); + cEffRatioPi->SaveAs("eff_ratio_pi.gif"); + cEffRatioPi->SaveAs("eff_ratio_pi.pdf"); + + TCanvas* cEffRatioK = new TCanvas("cEffRatioK", "eff K / eff all", 400, 300); + cEffRatioK->Clear(); + TF1* effRatioK = new TF1("effRatioK", "exp(-[1]*x)+[0]", 0.0, 50.0); + effRatioK->SetParameters(1.0, 1.0); + effRatioK->SetLineColor(6); + TH1D* hEffChargedRebinned = (TH1D*)hEff[0]->Clone("hEffChargedRebinned"); + hEffChargedRebinned->Rebin(2); + TH1D* hEffRatioK = (TH1D*)hEff[2]->Clone("hEffRatioK"); + hEffRatioK->Rebin(2); + hEffRatioK->SetTitle("; p_{T} [GeV/c]; #epsilon_{ch}/#epsilon_{K}"); + hEffRatioK->Divide(hEffChargedRebinned, hEffRatioK, 1, 1, "B"); + // hEffRatioK->Divide(hEff[1], hEff[0]); + hEffRatioK->GetXaxis()->SetRangeUser(0.0, 19.99); + hEffRatioK->GetYaxis()->SetRangeUser(0.8, 1.1); + hEffRatioK->SetStats(kTRUE); + hEffRatioK->Fit(effRatioK, "", "", ptmin, ptmax); + cEffRatioK->SaveAs("eff_ratio_K.gif"); + cEffRatioK->SaveAs("eff_ratio_K.pdf"); + + TCanvas* cEffRatioP = new TCanvas("cEffRatioP", "eff p / eff all", 400, 300); + cEffRatioP->Clear(); + TF1* effRatioP = new TF1("effRatioP", "pol0", 0.0, 50.0); + effRatioP->SetLineColor(6); + effRatioP->SetParameters(0.7, 0.5); + // TH1D* hEffChargedRebinned = (TH1D*)hEff[0]->Clone("hEffChargedRebinned"); + // hEffChargedRebinned->Rebin(2); + TH1D* hEffRatioP = (TH1D*)hEff[3]->Clone("hEffRatioP"); + hEffRatioP->Rebin(2); + hEffRatioP->SetTitle("; p_{T} [GeV/c]; #epsilon_{ch}/#epsilon_{p}"); + hEffRatioP->Divide(hEffChargedRebinned, hEffRatioP, 1, 1, "B"); + // hEffRatioP->Divide(hEff[1], hEff[0]); + hEffRatioP->GetXaxis()->SetRangeUser(0.0, 19.99); + hEffRatioP->GetYaxis()->SetRangeUser(0.8, 1.1); + hEffRatioP->SetStats(kTRUE); + hEffRatioP->Fit(effRatioP, "", "", ptmin, ptmax); + cEffRatioP->SaveAs("eff_ratio_p.gif"); + cEffRatioP->SaveAs("eff_ratio_p.pdf"); + + + // TCanvas* cMuonRatio = new TCanvas("cMuonRatio", "muon / all", 400, 300); + // cMuonRatio->Clear(); + // // TF1* pionMuon = new TF1("pionMuon", "pol0", 0.0, 50.0); + // TF1* muonRatio = new TF1("muonRatio", "pol0", 0.0, 50.0); + // muonRatio->SetLineColor(1); + // muonRatio->SetParameter(0, 0.01); + // TH1D* hMuonRatio = (TH1D*)hOut[5]->Clone("hMuonRatio"); + // hMuonRatio->SetTitle("; p_{T} [GeV/c]; muon/all"); + // hMuonRatio->Divide(hOut[5], hOut[0], 1, 1, "B"); + // hMuonRatio->GetYaxis()->SetRangeUser(0.0, 0.05); + // hMuonRatio->SetStats(kTRUE); + // hMuonRatio->Fit(muonRatio, "", "", ptmin, ptmax); + // cMuonRatio->SaveAs("muon_ratio.gif"); + // cMuonRatio->SaveAs("muon_ratio.pdf"); + + // TCanvas* cElectronRatio = new TCanvas("cElectronRatio", "electron / all", 400, 300); + // cElectronRatio->Clear(); + // // TF1* pionElectron = new TF1("pionElectron", "pol0", 0.0, 50.0); + // TF1* electronRatio = new TF1("electronRatio", "pol0", 0.0, 50.0); + // electronRatio->SetLineColor(1); + // electronRatio->SetParameter(0, 0.01); + // TH1D* hElectronRatio = (TH1D*)hOut[4]->Clone("hElectronRatio"); + // hElectronRatio->SetTitle("; p_{T} [GeV/c]; electron/all"); + // hElectronRatio->Divide(hOut[4], hOut[0], 1, 1, "B"); + // hElectronRatio->GetYaxis()->SetRangeUser(0.0, 0.05); + // hElectronRatio->SetStats(kTRUE); + // hElectronRatio->SetMarkerColor(6); + // hElectronRatio->Fit(electronRatio, "", "", ptmin, ptmax); + // cElectronRatio->SaveAs("electron_ratio.gif"); + // cElectronRatio->SaveAs("electron_ratio.pdf"); + + + TFile* effFile = new TFile(effFileName, "RECREATE"); + chEff->Write(); + pionEff->Write(); + kaonEff->Write(); + protonEff->Write(); + effFile->Close(); +} + + +//_______________________________________________________________________ +void DrawCorrection(const Char_t* fileNamePYTHIA, const Char_t* fileNamePHOJET) +{ + TFile* filePYTHIA = FindFileFresh(fileNamePYTHIA); + if(!filePYTHIA) + return; + + TFile* filePHOJET = FindFileFresh(fileNamePHOJET); + if(!filePHOJET) + return; + + gStyle->SetOptStat(0); + + const Double_t ptmin = 0.0; + const Double_t ptmax = 4.999; + // const Double_t ptmax = 49.999; + + const Double_t effmin = 0.95; + const Double_t effmax = 1.12; + + const Int_t nPid = 7; + + TH1D* hInPYTHIA[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + TH1D* hInPHOJET[nPid] = {0, 0, 0, 0, 0, 0, 0 }; + + for(Int_t pid = 0; pid < nPid; pid++) { + + hInPYTHIA[pid] = (TH1D*)filePYTHIA->Get(Form("hIn%d", pid)); + hInPYTHIA[pid]->GetXaxis()->SetRangeUser(ptmin, ptmax); + hInPYTHIA[pid]->GetYaxis()->SetRangeUser(effmin, effmax); + + hInPHOJET[pid] = (TH1D*)filePHOJET->Get(Form("hIn%d", pid)); + hInPHOJET[pid]->GetXaxis()->SetRangeUser(ptmin, ptmax); + hInPHOJET[pid]->GetYaxis()->SetRangeUser(effmin, effmax); + } + + hInPYTHIA[1]->Add(hInPYTHIA[2]); + hInPYTHIA[1]->Add(hInPYTHIA[3]); + hInPYTHIA[0]->Divide(hInPYTHIA[1], hInPYTHIA[0], 1, 1, "B"); + + TH1D* histPYTHIA = HistInvert(hInPYTHIA[0]); + histPYTHIA->SetLineColor(2); + histPYTHIA->SetMarkerColor(2); + + hInPHOJET[1]->Add(hInPHOJET[2]); + hInPHOJET[1]->Add(hInPHOJET[3]); + hInPHOJET[0]->Divide(hInPHOJET[1], hInPHOJET[0], 1, 1, "B"); + + TH1D* histPHOJET = HistInvert(hInPHOJET[0]); + histPHOJET->SetLineColor(4); + histPHOJET->SetMarkerColor(4); + + TCanvas* cChCorrection = new TCanvas("cChCorrection", "All efficiency", 400, 300); + cChCorrection->Clear(); + + cChCorrection->SetGridy(); + + histPYTHIA->GetYaxis()->SetRangeUser(effmin, effmax); + histPYTHIA->SetTitle("N_{ch}/(#pi + K + p) for primaries at generator level; p_{T} [GeV/c]; Ratio"); + histPYTHIA->Draw(); + + histPHOJET->Draw("SAME"); + + TLegend* legend = new TLegend(0.55, 0.22, 0.79, 0.42); + legend->SetBorderSize(0); + legend->SetFillColor(0); + legend->AddEntry(histPYTHIA, "PYTHIA", "P"); + legend->AddEntry(histPHOJET, "PHOJET", "P"); + legend->Draw(); + + cChCorrection->SaveAs("charged_over_piKp.gif"); + + TFile* file = new TFile("correction.root", "RECREATE"); + histPYTHIA->SetName("histPYTHIA"); + histPHOJET->SetName("histPHOJET"); + histPYTHIA->Write(); + histPHOJET->Write(); + file->Close(); +} + +//_______________________________________________________________________ +TH1D* HistInvert(TH1D* hist) +{ + TH1D* histNew = new TH1D(*hist); + histNew->Reset(); + histNew->SetName(Form("%s_inv", hist->GetName())); + histNew->SetTitle(Form("%s (inverted)", hist->GetTitle())); + + const Int_t nBins = hist->GetNbinsX(); + + for(Int_t i = 1; i <= nBins; i++) { + + if(hist->GetBinContent(i) == 0) + continue; + + histNew->SetBinContent(i, 1.0/hist->GetBinContent(i)); + histNew->SetBinError(i, hist->GetBinError(i)/hist->GetBinContent(i)/hist->GetBinContent(i)); + } + + return histNew; +} diff --git a/PWGLF/SPECTRA/IdentifiedHighPt/efficiency/lhc10d_eff_phojet.root b/PWGLF/SPECTRA/IdentifiedHighPt/efficiency/lhc10d_eff_phojet.root new file mode 100644 index 0000000000000000000000000000000000000000..94cf9cb53aa90ebcf01d74a60f398f2adc8d269f GIT binary patch literal 68609 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ⅈqD2l93boNo6;hx3u^ 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 literal 0 HcmV?d00001 diff --git a/PWGLF/SPECTRA/IdentifiedHighPt/final_spectra/charged_spectra/dNdPt_pp_2.76TeV.root b/PWGLF/SPECTRA/IdentifiedHighPt/final_spectra/charged_spectra/dNdPt_pp_2.76TeV.root new file mode 100644 index 0000000000000000000000000000000000000000..c93dc0cd9e4c7e3e65369bfac69f1ce7214486ef GIT binary patch literal 11697 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 Bh-d%+ literal 0 HcmV?d00001 diff --git a/PWGLF/SPECTRA/IdentifiedHighPt/final_spectra/charged_spectra/dNdPt_pp_7TeV.root b/PWGLF/SPECTRA/IdentifiedHighPt/final_spectra/charged_spectra/dNdPt_pp_7TeV.root new file mode 100644 index 0000000000000000000000000000000000000000..3633cd4906922088c610b9626e4b0c7948adc676 GIT binary patch literal 11765 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 +#include +#include +#include + +#include "my_tools.C" + +#include + +using namespace std; + +/* + Info: + + Method to convert charged pT histograms to have the same histogram binning + as our histograms have. They in general go to 100 GeV/c in pT while we only + go to 50. In that range the binning is EXACTLY the same (and the code checks + it). + + In charged spectra there is NO NORMALIZATION uncertainty. We add it by hand + to the syst error. + + * Need at some point to get the final spectra + * Need at some point to get the final normalization uncertainty + + + To run: + + gSystem->AddIncludePath("-I../macros") + gSystem->AddIncludePath("-I../lib") + gROOT->SetMacroPath(".:../macros") + .L my_tools.C+ + .L convertToMyBins.C+ + + + ConvertPPfile("charged_spectra/dNdPt_pp_7TeV.root", "NOPID_pp_7TeV.root", 0.034); + ConvertPPfile("charged_spectra/dNdPt_pp_2.76TeV.root", "NOPID_pp_2.76TeV.root", 0.034); + ConvertPPfile("charged_spectra/dNdPt_pp_900GeV.root", "NOPID_pp_900GeV.root", 0.034); + + + + + Older methods that can be useful for AA: + The method convertToMyBinsAA is for pp and AA spectra. + The method convertToMyBinsRaa is for RAA. + The method convertToMyBinsOld is for AA data when the centralities had to be merged. + + */ + + + +TH1D* Convert(TH1D* histIn, Double_t addSyst=0); +TH1D* ConvertGraph(TGraphErrors* graphIn); +void convertToMyBinsAA(); +void convertToMyBinsRaa(const Char_t* fileName = "PbPb_RAA_2760GeV_200511.root"); +void convertToMyBinsOld(const Char_t* fileName = "dndpt_all_2011-05-15.root"); + + +void ConvertPPfile(const Char_t* inFileName, const Char_t* outFileName, Double_t normSyst=0.0) +{ + TFile* fileDataCharged = FindFileFresh(inFileName); + + if(!fileDataCharged) + return; + + TH1D* hPtHelp = (TH1D*)fileDataCharged->Get("dNdPt_stat"); + TH1D* hPtCharged = Convert(hPtHelp); + hPtCharged->SetName("hDnDptCharged_PP"); + hPtCharged->SetMarkerStyle(29); + + hPtHelp = (TH1D*)fileDataCharged->Get("dNdPt_syst"); + TH1D* hPtChargedSyst = Convert(hPtHelp, normSyst); + hPtChargedSyst->SetName("hDnDptChargedSyst_PP"); + hPtChargedSyst->SetMarkerStyle(29); + + TFile* fileOut = new TFile(outFileName, "RECREATE"); + hPtCharged->Write(); + hPtChargedSyst->Write(); + fileOut->Close(); +} + +//________________________________________________________________________________________ +TH1D* Convert(TH1D* histIn, Double_t addSyst) +{ + const Int_t nPtBins = 68; + Double_t xBins[nPtBins+1] = {0. , 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, + 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, + 1.0, 1.1 , 1.2, 1.3 , 1.4, 1.5 , 1.6, 1.7 , 1.8, 1.9 , + 2.0, 2.2 , 2.4, 2.6 , 2.8, 3.0 , 3.2, 3.4 , 3.6, 3.8 , + 4.0, 4.5 , 5.0, 5.5 , 6.0, 6.5 , 7.0, 8.0 , 9.0, 10.0, + 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 18.0, 20.0, 22.0, 24.0, + 26.0, 28.0, 30.0, 32.0, 34.0, 36.0, 40.0, 45.0, 50.0 }; + + + TH1D* hist = new TH1D("hist", "", nPtBins, xBins); + hist->SetTitle(histIn->GetTitle()); + hist->GetXaxis()->SetTitle(histIn->GetXaxis()->GetTitle()); + hist->GetYaxis()->SetTitle(histIn->GetYaxis()->GetTitle()); + + const Double_t deltapt = 0.0001; + + for(Int_t bin = 1; bin <= nPtBins; bin++) { + + // check bin size + if(TMath::Abs(hist->GetXaxis()->GetBinLowEdge(bin) - + histIn->GetXaxis()->GetBinLowEdge(bin)) > deltapt) { + cout << "pt edge low does not agree!!!!!!!!!!!!!!!" << endl; + return 0; + } + if(TMath::Abs(hist->GetXaxis()->GetBinUpEdge(bin) - + histIn->GetXaxis()->GetBinUpEdge(bin)) > deltapt) { + cout << "pt edge high does not agree!!!!!!!!!!!!!!!" << endl; + return 0; + } + if(TMath::Abs(hist->GetXaxis()->GetBinCenter(bin) - + histIn->GetXaxis()->GetBinCenter(bin)) > deltapt) { + cout << "pt center does not agree!!!!!!!!!!!!!!!" << endl; + return 0; + } + + + hist->SetBinContent(bin, histIn->GetBinContent(bin)); + + Double_t error = histIn->GetBinError(bin); + if(addSyst) { + + Double_t extra_error = addSyst*histIn->GetBinContent(bin); + error = TMath::Sqrt(error*error + extra_error*extra_error); + } + hist->SetBinError(bin, error); + } + + return hist; +} + +//________________________________________________________________________________________ +TH1D* ConvertGraph(TGraphErrors* graphIn) +{ + const Int_t nPtBins = 68; + Double_t xBins[nPtBins+1] = {0. , 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, + 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, + 1.0, 1.1 , 1.2, 1.3 , 1.4, 1.5 , 1.6, 1.7 , 1.8, 1.9 , + 2.0, 2.2 , 2.4, 2.6 , 2.8, 3.0 , 3.2, 3.4 , 3.6, 3.8 , + 4.0, 4.5 , 5.0, 5.5 , 6.0, 6.5 , 7.0, 8.0 , 9.0, 10.0, + 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 18.0, 20.0, 22.0, 24.0, + 26.0, 28.0, 30.0, 32.0, 34.0, 36.0, 40.0, 45.0, 50.0 }; + + + TH1D* hist = new TH1D("hist", "", nPtBins, xBins); + // hist->SetTitle(graphIn->GetTitle()); + // hist->GetXaxis()->SetTitle(graphIn->GetXaxis()->GetTitle()); + // hist->GetYaxis()->SetTitle(graphIn->GetYaxis()->GetTitle()); + + const Double_t deltapt = 0.0001; + + // Jacek does not fill the first 3 bins of his graph? + for(Int_t bin = 4; bin <= nPtBins; bin++) { + + // check bin size + if(TMath::Abs(hist->GetXaxis()->GetBinCenter(bin) - + graphIn->GetX()[bin-1]) > deltapt) { + cout << "pt center does not agree!!!!!!!!!!!!!!!" << endl; + return 0; + } + + + hist->SetBinContent(bin, graphIn->GetY()[bin-1]); + hist->SetBinError(bin, graphIn->GetEY()[bin-1]); + } + + return hist; +} + +//________________________________________________________________________________________ +void convertToMyBinsAA() +{ + const Int_t nCent = 7; + const Int_t cent[nCent+1] = {-5, 0, 5, 10, 20, 40, 60, 80}; + const Int_t colors[nCent] = {kBlack, kRed+1, kOrange+7, kOrange, kGreen+2, kCyan+2, kBlue+1}; + + TH1D* hPtCharged[nCent] = {0, 0, 0, 0, 0, 0, 0}; + TH1D* hPtChargedSyst[nCent] = {0, 0, 0, 0, 0, 0, 0}; + + for (Int_t i = 0; i < nCent; i++) { + + if(cent[i]==-5) { + + TFile* fileDataCharged = FindFileFresh("dNdPt_pp_2.76TeV.root"); + + if(!fileDataCharged) + return; + + TH1D* hPtHelp = (TH1D*)fileDataCharged->Get("dNdPt_stat"); + hPtCharged[i] = Convert(hPtHelp); + hPtCharged[i]->SetName("hDnDptCharged_PP"); + hPtCharged[i]->SetMarkerColor(colors[i]); + hPtCharged[i]->SetMarkerStyle(29); + hPtHelp = (TH1D*)fileDataCharged->Get("dNdPt_syst"); + hPtChargedSyst[i] = Convert(hPtHelp, 0.034); // 3.4 % norm error + /* + Dear Peter, + + for 2.76TeV the systematic error for MB->INEL is 3.40%,, we decided to + drop the uncertainty from VdM scan since we don't really use it... + + Michael + */ + hPtChargedSyst[i]->SetName("hDnDptChargedSyst_PP"); + hPtChargedSyst[i]->SetMarkerColor(colors[i]); + hPtChargedSyst[i]->SetMarkerStyle(29); + } else { + + TFile* fileDataCharged = FindFileFresh(Form("dNdPt_PbPb_2.76ATeV_centrality_%d-%d.root", cent[i], cent[i+1])); + + if(!fileDataCharged) + return; + + TH1D* hPtHelp = (TH1D*)fileDataCharged->Get("dNdPt_stat"); + hPtCharged[i] = Convert(hPtHelp); + hPtCharged[i]->SetName(Form("hDnDptCharged_%d_%d", cent[i], cent[i+1])); + hPtCharged[i]->SetMarkerColor(colors[i]); + hPtCharged[i]->SetMarkerStyle(29); + hPtHelp = (TH1D*)fileDataCharged->Get("dNdPt_syst"); + hPtChargedSyst[i] = Convert(hPtHelp); + hPtChargedSyst[i]->SetName(Form("hDnDptChargedSyst_%d_%d", cent[i], cent[i+1])); + hPtChargedSyst[i]->SetMarkerColor(colors[i]); + hPtChargedSyst[i]->SetMarkerStyle(29); + } + } + + TFile* fileOut = new TFile("dNdPt_Charged.root", "RECREATE"); + for (Int_t i = 0; i < nCent; i++) { + hPtCharged[i]->Write(); + hPtChargedSyst[i]->Write(); + } + fileOut->Close(); +} + +//________________________________________________________________________________________ +void convertToMyBinsRaa(const Char_t* fileName) +{ + TFile* fileData = FindFileFresh(fileName); + + if(!fileData) + return; + + TGraphErrors* hRaa_0_5 = (TGraphErrors*)fileData->Get("raa_c0_5_stat"); + TH1D* hRaaCharged_0_5 = ConvertGraph(hRaa_0_5); + hRaaCharged_0_5->SetName("hRaaCharged_0_5"); + + TGraphErrors* hRaa_5_10 = (TGraphErrors*)fileData->Get("raa_c5_10_stat"); + TH1D* hRaaCharged_5_10 = ConvertGraph(hRaa_5_10); + hRaaCharged_5_10->SetName("hRaaCharged_5_10"); + + TGraphErrors* hRaa_10_20 = (TGraphErrors*)fileData->Get("raa_c10_20_stat"); + TH1D* hRaaCharged_10_20 = ConvertGraph(hRaa_10_20); + hRaaCharged_10_20->SetName("hRaaCharged_10_20"); + + TGraphErrors* hRaa_20_40 = (TGraphErrors*)fileData->Get("raa_c20_40_stat"); + TH1D* hRaaCharged_20_40 = ConvertGraph(hRaa_20_40); + hRaaCharged_20_40->SetName("hRaaCharged_20_40"); + + TGraphErrors* hRaa_40_60 = (TGraphErrors*)fileData->Get("raa_c40_60_stat"); + TH1D* hRaaCharged_40_60 = ConvertGraph(hRaa_40_60); + hRaaCharged_40_60->SetName("hRaaCharged_40_60"); + + TGraphErrors* hRaa_60_80 = (TGraphErrors*)fileData->Get("raa_c60_80_stat"); + TH1D* hRaaCharged_60_80 = ConvertGraph(hRaa_60_80); + hRaaCharged_60_80->SetName("hRaaCharged_60_80"); + + TGraphErrors* hRaa_0_20 = (TGraphErrors*)fileData->Get("raa_c0_20_stat"); + TH1D* hRaaCharged_0_20 = ConvertGraph(hRaa_0_20); + hRaaCharged_0_20->SetName("hRaaCharged_0_20"); + + TGraphErrors* hRaa_40_80 = (TGraphErrors*)fileData->Get("raa_c40_80_stat"); + TH1D* hRaaCharged_40_80 = ConvertGraph(hRaa_40_80); + hRaaCharged_40_80->SetName("hRaaCharged_40_80"); + + + TFile* fileOut = new TFile("Raa_Charged.root", "RECREATE"); + hRaaCharged_0_5->Write(); + hRaaCharged_5_10->Write(); + hRaaCharged_10_20->Write(); + hRaaCharged_20_40->Write(); + hRaaCharged_40_60->Write(); + hRaaCharged_60_80->Write(); + hRaaCharged_0_20->Write(); + hRaaCharged_40_80->Write(); + fileOut->Close(); +} + +//________________________________________________________________________________________ + +void convertToMyBinsOld(const Char_t* fileName) +{ + TFile* fileData = FindFileFresh(fileName); + + if(!fileData) + return; + + TH1D* hDnDPt_0_5 = (TH1D*)fileData->Get("dNdPt_PbPb_c0_5"); + TH1D* hDnDptCharged_0_5 = Convert(hDnDPt_0_5); + hDnDptCharged_0_5->SetName("hDnDptCharged_0_5"); + + TH1D* hDnDPt_5_10 = (TH1D*)fileData->Get("dNdPt_PbPb_c5_10"); + TH1D* hDnDptCharged_5_10 = Convert(hDnDPt_5_10); + hDnDptCharged_5_10->SetName("hDnDptCharged_5_10"); + + TH1D* hDnDPt_10_20 = (TH1D*)fileData->Get("dNdPt_PbPb_c10_20"); + TH1D* hDnDptCharged_10_20 = Convert(hDnDPt_10_20); + hDnDptCharged_10_20->SetName("hDnDptCharged_10_20"); + + TH1D* hDnDPt_20_40 = (TH1D*)fileData->Get("dNdPt_PbPb_c20_30"); + TH1D* hHelp = (TH1D*)fileData->Get("dNdPt_PbPb_c30_40"); + hDnDPt_20_40->Add(hHelp); + hDnDPt_20_40->Scale(1.0/2.0); + TH1D* hDnDptCharged_20_40 = Convert(hDnDPt_20_40); + hDnDptCharged_20_40->SetName("hDnDptCharged_20_40"); + + TH1D* hDnDPt_40_60 = (TH1D*)fileData->Get("dNdPt_PbPb_c40_50"); + hHelp = (TH1D*)fileData->Get("dNdPt_PbPb_c50_60"); + hDnDPt_40_60->Add(hHelp); + hDnDPt_40_60->Scale(1.0/2.0); + TH1D* hDnDptCharged_40_60 = Convert(hDnDPt_40_60); + hDnDptCharged_40_60->SetName("hDnDptCharged_40_60"); + + TH1D* hDnDPt_60_80 = (TH1D*)fileData->Get("dNdPt_PbPb_c60_70"); + hHelp = (TH1D*)fileData->Get("dNdPt_PbPb_c70_80"); + hDnDPt_60_80->Add(hHelp); + hDnDPt_60_80->Scale(1.0/2.0); + TH1D* hDnDptCharged_60_80 = Convert(hDnDPt_60_80); + hDnDptCharged_60_80->SetName("hDnDptCharged_60_80"); + + + TFile* fileOut = new TFile("dNdPt_Charged.root", "RECREATE"); + hDnDptCharged_0_5->Write(); + hDnDptCharged_5_10->Write(); + hDnDptCharged_10_20->Write(); + hDnDptCharged_20_40->Write(); + hDnDptCharged_40_60->Write(); + hDnDptCharged_60_80->Write(); + fileOut->Close(); +} diff --git a/PWGLF/SPECTRA/IdentifiedHighPt/final_spectra/makeSpectra.C b/PWGLF/SPECTRA/IdentifiedHighPt/final_spectra/makeSpectra.C new file mode 100644 index 00000000000..a9f29cfa811 --- /dev/null +++ b/PWGLF/SPECTRA/IdentifiedHighPt/final_spectra/makeSpectra.C @@ -0,0 +1,112 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "my_tools.C" + + +/* + Info: + Multiplies the fraction with the charged spectrum. + Applies a rapidity correction in case of K and p. + + To run: + + gSystem->AddIncludePath("-I../macros") + gSystem->AddIncludePath("-I../lib") + gROOT->SetMacroPath(".:../macros") + .L my_tools.C+ + .L makeSpectra.C+ + + MakeSpectra("../corrected_fraction/fraction_7tev_b_all.root", "NOPID_pp_7TeV.root", "final_spectra_7tev_b.root"); + + + */ + +Double_t rap_correction(Double_t* x, Double_t* par); + +void MakeSpectra(const Char_t* fileName, + const Char_t* fileNameCharged, + const Char_t* outFileName, + const Char_t* endName="PP") +{ + TFile* fileData = FindFileFresh(fileName); + + if(!fileData) + return; + + TFile* fileDataCharged = FindFileFresh(fileNameCharged); + + if(!fileDataCharged) + return; + + const Int_t nPid = 3; + const Char_t* pidNames[nPid] = {"Pion", "Kaon", "Proton"}; + const Char_t* titleNames[nPid] = {"#pi^{+} + #pi^{-}", "K^{+} + K^{-}", "p + #bar{p}"}; + const Double_t mass[nPid] = {0.140, 0.494, 0.938}; + + TH1D* hPtSpectrum[nPid] = {0, 0, 0}; + TH1D* hPtSpectrumSyst[nPid] = {0, 0, 0}; + + TH1D* hPtCharged = (TH1D*)fileDataCharged->Get(Form("hDnDptCharged_%s", endName)); + TH1D* hPtChargedSyst = (TH1D*)fileDataCharged->Get(Form("hDnDptChargedSyst_%s", endName)); + + TF1* fRap = new TF1("fRap", rap_correction, 0.0, 50.0, 2); + + for(Int_t pid = 0; pid < nPid; pid++) { + + // Pions + TH1D* hFraction = (TH1D*)fileData->Get(Form("h%sFraction_%s", pidNames[pid], endName)); + TH1D* hFractionSyst = (TH1D*)fileData->Get(Form("h%sFractionSyst_%s", pidNames[pid], endName)); + + hPtSpectrum[pid] = (TH1D*)hFraction->Clone(Form("h%sSpectrum_%s", pidNames[pid], endName)); + hPtSpectrum[pid]->GetYaxis()->SetTitle(Form("1/N_{evt} 1/(2#pi p_{T}) (d^{2}N_{%s})/(dy dp_{T}) (GeV/c)^{-2}", titleNames[pid])); + hPtSpectrum[pid]->Multiply(hPtCharged); + + hPtSpectrumSyst[pid] = (TH1D*)hFractionSyst->Clone(Form("h%sSpectrumSyst_%s", pidNames[pid], endName)); + hPtSpectrumSyst[pid]->SetMarkerStyle(1); + hPtSpectrum[pid]->GetYaxis()->SetTitle(Form("1/N_{evt} 1/(2#pi p_{T}) (d^{2}N_{%s})/(dy dp_{T}) (GeV/c)^{-2}", titleNames[pid])); + hPtSpectrumSyst[pid]->Multiply(hPtChargedSyst); + hPtSpectrumSyst[pid]->SetFillStyle(1001); + hPtSpectrumSyst[pid]->SetFillColor(kGray); + + // + // Rapidity correction + // + fRap->SetParameters(0.8, mass[pid]); + hPtSpectrum[pid]->Divide(fRap); + hPtSpectrumSyst[pid]->Divide(fRap); + } + + TFile* fileOut = new TFile(outFileName, "RECREATE"); + for(Int_t pid = 0; pid < nPid; pid++) { + hPtSpectrumSyst[pid]->Write(); + hPtSpectrum[pid]->Write(); + } + fileOut->Close(); +} + +//______________________________________________________________________________ +Double_t rap_correction(Double_t* x, Double_t* par) +{ + Double_t pt = x[0]; + + Double_t eta = par[0]; + Double_t mass = par[1]; + + const Double_t mt = TMath::Sqrt(pt*pt + mass*mass); + + const Double_t rap = TMath::ASinH(pt/mt*TMath::SinH(eta)); + + return rap/eta; +} diff --git a/PWGLF/SPECTRA/IdentifiedHighPt/grid/AddTaskHighPtDeDx.C b/PWGLF/SPECTRA/IdentifiedHighPt/grid/AddTaskHighPtDeDx.C new file mode 100644 index 00000000000..ae28a2ebe02 --- /dev/null +++ b/PWGLF/SPECTRA/IdentifiedHighPt/grid/AddTaskHighPtDeDx.C @@ -0,0 +1,185 @@ +AliAnalysisTask* AddTask(Bool_t AnalysisMC, const Char_t* taskname, Int_t typerun, UInt_t kTriggerInt[], Float_t minc[], Float_t maxc[] ) +{ + // Creates a pid task and adds it to the analysis manager + + // Get the pointer to the existing analysis manager via the static + //access method + //========================================================================= + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) { + Error("AddTaskHighPtDeDx", "No analysis manager to connect to."); + return NULL; + } + + // Check the analysis type using the event handlers connected to the + // analysis manager The availability of MC handler can also be + // checked here. + // ========================================================================= + if (!mgr->GetInputEventHandler()) { + Error("AddTaskHighPtDeDx", "This task requires an input event handler"); + return NULL; + } + + + + // + // Add track filters, with Golden Cuts + // + AliAnalysisFilter* trackFilterGolden = new AliAnalysisFilter("trackFilter"); + AliESDtrackCuts* esdTrackCutsGolden = + AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kTRUE); + trackFilterGolden->AddCuts(esdTrackCutsGolden); + + + //old cuts without golden cut + AliAnalysisFilter* trackFilter0 = new AliAnalysisFilter("trackFilter"); + Bool_t clusterCut=0; + Bool_t selPrimaries=kTRUE; + AliESDtrackCuts* esdTrackCutsL0 = new AliESDtrackCuts; + // TPC + if(clusterCut == 0) esdTrackCutsL0->SetMinNClustersTPC(70); + else if (clusterCut == 1) { + esdTrackCutsL0->SetMinNCrossedRowsTPC(70); + esdTrackCutsL0->SetMinRatioCrossedRowsOverFindableClustersTPC(0.8); + } + else { + AliWarningClass(Form("Wrong value of the clusterCut parameter (%d), using cut on Nclusters",clusterCut)); + esdTrackCutsL0->SetMinNClustersTPC(70); + } + esdTrackCutsL0->SetMaxChi2PerClusterTPC(4); + esdTrackCutsL0->SetAcceptKinkDaughters(kFALSE); + esdTrackCutsL0->SetRequireTPCRefit(kTRUE); + // ITS + esdTrackCutsL0->SetRequireITSRefit(kTRUE); + esdTrackCutsL0->SetClusterRequirementITS(AliESDtrackCuts::kSPD, + AliESDtrackCuts::kAny); + if(selPrimaries) { + // 7*(0.0026+0.0050/pt^1.01) + esdTrackCutsL0->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01"); + } + esdTrackCutsL0->SetMaxDCAToVertexZ(2); + esdTrackCutsL0->SetDCAToVertex2D(kFALSE); + esdTrackCutsL0->SetRequireSigmaToVertex(kFALSE); + esdTrackCutsL0->SetMaxChi2PerClusterITS(1e10); + esdTrackCutsL0->SetMaxChi2TPCConstrainedGlobal(1e10); + + + trackFilter0->AddCuts(esdTrackCutsL0); + + + + AliAnalysisFilter* trackFilterTPC = new AliAnalysisFilter("trackFilterTPC"); + AliESDtrackCuts* esdTrackCutsTPC = + AliESDtrackCuts::GetStandardTPCOnlyTrackCuts(); + trackFilterTPC->AddCuts(esdTrackCutsTPC); + + + + // Create the task and configure it + //======================================================================== + if(typerun==2){//heavy ion analysis + + + AliAnalysisTaskHighPtDeDx* taskHighPtDeDx[6]; + for( Int_t i=0; i<6; ++i ){ + taskHighPtDeDx[i]=0; + Char_t TaskName[256]={0}; + sprintf(TaskName,"%s_%1.0f_%1.0f",taskname,minc[i],maxc[i]); + + taskHighPtDeDx[i] = new AliAnalysisTaskHighPtDeDx(TaskName); + TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD" + taskHighPtDeDx[i]->SetAnalysisType(type); + taskHighPtDeDx[i]->SetAnalysisMC(AnalysisMC); + taskHighPtDeDx[i]->SetAnalysisPbPb(kTRUE); + taskHighPtDeDx[i]->SetProduceTPCBranch(kFALSE); + taskHighPtDeDx[i]->SetDebugLevel(0); + taskHighPtDeDx[i]->SetEtaCut(0.8); + taskHighPtDeDx[i]->SetVtxCut(10.0); + taskHighPtDeDx[i]->SetMinPt(0.0); // default 2.0 + taskHighPtDeDx[i]->SetLowPtFraction(0.01); // keep 1% of tracks below min pt + taskHighPtDeDx[i]->SetTreeOption(1); + taskHighPtDeDx[i]->SetTrigger1(kTriggerInt[0]); + taskHighPtDeDx[i]->SetTrigger2(kTriggerInt[1]); + taskHighPtDeDx[i]->SetMinCent(minc[i]); + taskHighPtDeDx[i]->SetMaxCent(maxc[i]); + //Set Filtesr + taskHighPtDeDx[i]->SetTrackFilterGolden(trackFilterGolden); + taskHighPtDeDx[i]->SetTrackFilter(trackFilter0); + taskHighPtDeDx[i]->SetTrackFilterTPC(trackFilterTPC); + + mgr->AddTask(taskHighPtDeDx[i]); + + } + + // Create ONLY the output containers for the data produced by the + // task. Get and connect other common input/output containers via + // the manager as below + //======================================================================= + AliAnalysisDataContainer *cout_hist[6]; + for( Int_t i=0; i<6; ++i ){ + + cout_hist[i]=0; + Char_t outFileName[256]={0}; + sprintf(outFileName,"%s_Tree_%1.0f_%1.0f.root",taskname,minc[i],maxc[i]); + //AliAnalysisDataContainer *cout_hist = 0; + + cout_hist[i] = mgr->CreateContainer(Form("output_%1.0f_%1.0f",minc[i],maxc[i]), TList::Class(), AliAnalysisManager::kOutputContainer, outFileName); + mgr->ConnectInput (taskHighPtDeDx[i], 0, mgr->GetCommonInputContainer()); + mgr->ConnectOutput(taskHighPtDeDx[i], 1, cout_hist[i]); + + } + + // Return task pointer at the end + return taskHighPtDeDx[0]; + } + if(typerun==3){//pp analysis + + + AliAnalysisTaskHighPtDeDx* taskHighPtDeDx = new AliAnalysisTaskHighPtDeDx("taskHighPtDeDxpp"); + TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD" + taskHighPtDeDx->SetAnalysisType(type); + taskHighPtDeDx->SetAnalysisMC(AnalysisMC); + taskHighPtDeDx->SetAnalysisPbPb(kFALSE); + taskHighPtDeDx->SetProduceTPCBranch(kFALSE); + taskHighPtDeDx->SetDebugLevel(0); + taskHighPtDeDx->SetEtaCut(0.8); + taskHighPtDeDx->SetVtxCut(10.0); + taskHighPtDeDx->SetMinPt(0.0); // default 2.0 + taskHighPtDeDx->SetLowPtFraction(0.01); // keep 1% of tracks below min pt + taskHighPtDeDx->SetTreeOption(1); + taskHighPtDeDx->SetTrigger1(kTriggerInt[0]); + taskHighPtDeDx->SetTrigger2(kTriggerInt[1]); + //Set Filtesr + taskHighPtDeDx->SetTrackFilterGolden(trackFilterGolden); + taskHighPtDeDx->SetTrackFilter(trackFilter0); + taskHighPtDeDx->SetTrackFilterTPC(trackFilterTPC); + + mgr->AddTask(taskHighPtDeDx); + + // Create ONLY the output containers for the data produced by the + // task. Get and connect other common input/output containers via + // the manager as below + //======================================================================= + + AliAnalysisDataContainer *cout_histdedx; + + cout_histdedx=0; + Char_t outFileName[256]={0}; + sprintf(outFileName,"%s_Tree.root",taskname); + //AliAnalysisDataContainer *cout_hist = 0; + + cout_histdedx = mgr->CreateContainer("outputdedx", TList::Class(), AliAnalysisManager::kOutputContainer, outFileName); + mgr->ConnectInput (taskHighPtDeDx, 0, mgr->GetCommonInputContainer()); + mgr->ConnectOutput(taskHighPtDeDx, 1, cout_histdedx); + + // Return task pointer at the end + return taskHighPtDeDx; + + + + + + } + + +} diff --git a/PWGLF/SPECTRA/IdentifiedHighPt/grid/AddTaskHighPtDeDxV0.C b/PWGLF/SPECTRA/IdentifiedHighPt/grid/AddTaskHighPtDeDxV0.C new file mode 100644 index 00000000000..14ff6c190b9 --- /dev/null +++ b/PWGLF/SPECTRA/IdentifiedHighPt/grid/AddTaskHighPtDeDxV0.C @@ -0,0 +1,190 @@ +AliAnalysisTask* AddTask(Bool_t AnalysisMC, const Char_t* taskname, Int_t typerun, UInt_t kTriggerInt[], Float_t minc[], Float_t maxc[] ) +{ + // Creates a pid task and adds it to the analysis manager + + // Get the pointer to the existing analysis manager via the static + //access method + //========================================================================= + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) { + Error("AddTaskHighPtDeDx", "No analysis manager to connect to."); + return NULL; + } + + // Check the analysis type using the event handlers connected to the + // analysis manager The availability of MC handler can also be + // checked here. + // ========================================================================= + if (!mgr->GetInputEventHandler()) { + Error("AddTaskHighPtDeDx", "This task requires an input event handler"); + return NULL; + } + + // + // Add track filters, with Golden Cuts + // + AliAnalysisFilter* trackFilterGolden = new AliAnalysisFilter("trackFilter"); + AliESDtrackCuts* esdTrackCutsGolden = + AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kTRUE); + trackFilterGolden->AddCuts(esdTrackCutsGolden); + + + //old cuts without golden cut + AliAnalysisFilter* trackFilter0 = new AliAnalysisFilter("trackFilter"); + Bool_t clusterCut=0; + Bool_t selPrimaries=kTRUE; + AliESDtrackCuts* esdTrackCutsL0 = new AliESDtrackCuts; + // TPC + if(clusterCut == 0) esdTrackCutsL0->SetMinNClustersTPC(70); + else if (clusterCut == 1) { + esdTrackCutsL0->SetMinNCrossedRowsTPC(70); + esdTrackCutsL0->SetMinRatioCrossedRowsOverFindableClustersTPC(0.8); + } + else { + AliWarningClass(Form("Wrong value of the clusterCut parameter (%d), using cut on Nclusters",clusterCut)); + esdTrackCutsL0->SetMinNClustersTPC(70); + } + esdTrackCutsL0->SetMaxChi2PerClusterTPC(4); + esdTrackCutsL0->SetAcceptKinkDaughters(kFALSE); + esdTrackCutsL0->SetRequireTPCRefit(kTRUE); + // ITS + esdTrackCutsL0->SetRequireITSRefit(kTRUE); + esdTrackCutsL0->SetClusterRequirementITS(AliESDtrackCuts::kSPD, + AliESDtrackCuts::kAny); + if(selPrimaries) { + // 7*(0.0026+0.0050/pt^1.01) + esdTrackCutsL0->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01"); + } + esdTrackCutsL0->SetMaxDCAToVertexZ(2); + esdTrackCutsL0->SetDCAToVertex2D(kFALSE); + esdTrackCutsL0->SetRequireSigmaToVertex(kFALSE); + esdTrackCutsL0->SetMaxChi2PerClusterITS(1e10); + esdTrackCutsL0->SetMaxChi2TPCConstrainedGlobal(1e10); + + + trackFilter0->AddCuts(esdTrackCutsL0); + + + + AliAnalysisFilter* trackFilterTPC = new AliAnalysisFilter("trackFilterTPC"); + AliESDtrackCuts* esdTrackCutsTPC = + AliESDtrackCuts::GetStandardTPCOnlyTrackCuts(); + trackFilterTPC->AddCuts(esdTrackCutsTPC); + + + // Create the task and configure it + //======================================================================== + if(typerun==2){//heavy ion analysis + + AliAnalysisTaskHighPtDeDxV0* taskHighPtDeDxV0[6]; + for( Int_t i=0; i<6; ++i ){ + taskHighPtDeDxV0[i]=0; + Char_t TaskName[256]={0}; + sprintf(TaskName,"%s_%1.0f_%1.0f",taskname,minc[i],maxc[i]); + + taskHighPtDeDxV0[i] = new AliAnalysisTaskHighPtDeDxV0(TaskName); + TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD" + + taskHighPtDeDxV0[i]->SetAnalysisType(type); + taskHighPtDeDxV0[i]->SetAnalysisMC(AnalysisMC); + taskHighPtDeDxV0[i]->SetAnalysisPbPb(kTRUE); + taskHighPtDeDxV0[i]->SetProduceTPCBranch(kFALSE); + taskHighPtDeDxV0[i]->SetDebugLevel(0); + taskHighPtDeDxV0[i]->SetEtaCut(0.8); + taskHighPtDeDxV0[i]->SetVtxCut(10.0); + taskHighPtDeDxV0[i]->SetMinPt(0.0); // def: 2.0 + taskHighPtDeDxV0[i]->SetMassCut(0.1); // def: 0.03 + taskHighPtDeDxV0[i]->SetTreeOption(1); + taskHighPtDeDxV0[i]->SetRequireRecV0(kFALSE); // def: kTRUE + taskHighPtDeDxV0[i]->SetStoreMcIn(kTRUE); // def: kFALSE + taskHighPtDeDxV0[i]->SetTrigger1(kTriggerInt[0]); + taskHighPtDeDxV0[i]->SetTrigger2(kTriggerInt[1]); + taskHighPtDeDxV0[i]->SetMinCent(minc[i]); + taskHighPtDeDxV0[i]->SetMaxCent(maxc[i]); + //Set Filtesr + taskHighPtDeDxV0[i]->SetTrackFilterGolden(trackFilterGolden); + taskHighPtDeDxV0[i]->SetTrackFilter(trackFilter0); + taskHighPtDeDxV0[i]->SetTrackFilterTPC(trackFilterTPC); + + mgr->AddTask(taskHighPtDeDxV0[i]); + + + } + + // Create ONLY the output containers for the data produced by the + // task. Get and connect other common input/output containers via + // the manager as below + //======================================================================= + AliAnalysisDataContainer *cout_hist[6]; + for( Int_t i=0; i<6; ++i ){ + + cout_hist[i]=0; + Char_t outFileName[256]={0}; + sprintf(outFileName,"%s_Tree_%1.0f_%1.0f.root",taskname,minc[i],maxc[i]); + //AliAnalysisDataContainer *cout_hist = 0; + + cout_hist[i] = mgr->CreateContainer(Form("output_%1.0f_%1.0f",minc[i],maxc[i]), TList::Class(), AliAnalysisManager::kOutputContainer, outFileName); + mgr->ConnectInput (taskHighPtDeDxV0[i], 0, mgr->GetCommonInputContainer()); + mgr->ConnectOutput(taskHighPtDeDxV0[i], 1, cout_hist[i]); + + } + + // Return task pointer at the end + return taskHighPtDeDxV0[0]; + } + + if(typerun==3){//pp analysis + + AliAnalysisTaskHighPtDeDxV0* taskHighPtDeDxV0 = new AliAnalysisTaskHighPtDeDxV0("taskHighPtDeDxV0pp"); + TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD" + + taskHighPtDeDxV0->SetAnalysisType(type); + taskHighPtDeDxV0->SetAnalysisMC(AnalysisMC); + taskHighPtDeDxV0->SetAnalysisPbPb(kFALSE); + taskHighPtDeDxV0->SetProduceTPCBranch(kFALSE); + taskHighPtDeDxV0->SetDebugLevel(0); + taskHighPtDeDxV0->SetEtaCut(0.8); + taskHighPtDeDxV0->SetVtxCut(10.0); + taskHighPtDeDxV0->SetMinPt(0.0); // def: 2.0 + taskHighPtDeDxV0->SetMassCut(0.03); // def: 0.03 + taskHighPtDeDxV0->SetTreeOption(1); + taskHighPtDeDxV0->SetRequireRecV0(kTRUE); // def: kTRUE + taskHighPtDeDxV0->SetStoreMcIn(kFALSE); // def: kFALSE + taskHighPtDeDxV0->SetTrigger1(kTriggerInt[0]); + taskHighPtDeDxV0->SetTrigger2(kTriggerInt[1]); + //Set Filtesr + taskHighPtDeDxV0->SetTrackFilterGolden(trackFilterGolden); + taskHighPtDeDxV0->SetTrackFilter(trackFilter0); + taskHighPtDeDxV0->SetTrackFilterTPC(trackFilterTPC); + + mgr->AddTask(taskHighPtDeDxV0); + + + + // Create ONLY the output containers for the data produced by the + // task. Get and connect other common input/output containers via + // the manager as below + //======================================================================= + AliAnalysisDataContainer *cout_histdedxv0; + + cout_histdedxv0=0; + Char_t outFileName[256]={0}; + sprintf(outFileName,"%s_Tree.root",taskname); + //AliAnalysisDataContainer *cout_hist = 0; + + cout_histdedxv0 = mgr->CreateContainer("output", TList::Class(), AliAnalysisManager::kOutputContainer, outFileName); + mgr->ConnectInput (taskHighPtDeDxV0, 0, mgr->GetCommonInputContainer()); + mgr->ConnectOutput(taskHighPtDeDxV0, 1, cout_histdedxv0); + + // Return task pointer at the end + return taskHighPtDeDxV0; + + + } + + + + + + +} diff --git a/PWGLF/SPECTRA/IdentifiedHighPt/grid/AliAnalysisTaskHighPtDeDx.cxx b/PWGLF/SPECTRA/IdentifiedHighPt/grid/AliAnalysisTaskHighPtDeDx.cxx new file mode 100644 index 00000000000..096f51ead54 --- /dev/null +++ b/PWGLF/SPECTRA/IdentifiedHighPt/grid/AliAnalysisTaskHighPtDeDx.cxx @@ -0,0 +1,1705 @@ +#include "AliAnalysisTaskHighPtDeDx.h" + +// ROOT includes +#include +#include +#include +#include +#include +#include + +// AliRoot includes +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +#include +#include +#include + +#include "AliCentrality.h" + +#include +#include +#include + + +// STL includes +#include +using namespace std; + + +// +// Responsible: +// Alexandru Dobrin (Wayne State) +// Peter Christiansen (Lund) +// + +/* +To do: + +Separate the code into two + +*/ + + + + +ClassImp(AliAnalysisTaskHighPtDeDx) + +const Double_t AliAnalysisTaskHighPtDeDx::fgkClight = 2.99792458e-2; + +//_____________________________________________________________________________ +AliAnalysisTaskHighPtDeDx::AliAnalysisTaskHighPtDeDx(): + AliAnalysisTaskSE(), + fESD(0x0), + fAOD(0x0), + fMC(0x0), + fMCStack(0x0), + fMCArray(0x0), + fTrackFilter(0x0), + fTrackFilterGolden(0x0), + fTrackFilterTPC(0x0), + fAnalysisType("ESD"), + fAnalysisMC(kFALSE), + fAnalysisPbPb(kFALSE), + fTPCBranch(kFALSE), + ftrigBit1(0x0), + ftrigBit2(0x0), + fRandom(0x0), + fEvent(0x0), + fTrackArrayGlobalPar(0x0), + fTrackArrayTPCPar(0x0), + fTrackArrayMC(0x0), + fVZEROArray(0x0), + fVtxCut(10.0), + fEtaCut(0.9), + fMinPt(0.1), + fMinCent(0.0), + fMaxCent(100.0), + fLowPtFraction(0.01), + fTreeOption(0), + fMcProcessType(-999), + fTriggeredEventMB(-999), + fVtxStatus(-999), + fZvtx(-999), + fZvtxMC(-999), + fRun(-999), + fEventId(-999), + fListOfObjects(0), + fEvents(0x0), fVtx(0x0), fVtxMC(0x0), fVtxBeforeCuts(0x0), fVtxAfterCuts(0x0), + fTree(0x0), + fn1(0), + fn2(0), + fcent(0) + + +{ + // Default constructor (should not be used) + + // fRandom = new TRandom(0); // 0 means random seed +} + +//______________________________________________________________________________ +AliAnalysisTaskHighPtDeDx::AliAnalysisTaskHighPtDeDx(const char *name): + AliAnalysisTaskSE(name), + fESD(0x0), + fAOD(0x0), + fMC(0x0), + fMCStack(0x0), + fMCArray(0x0), + fTrackFilter(0x0), + fTrackFilterGolden(0x0), + fTrackFilterTPC(0x0), + fAnalysisType("ESD"), + fAnalysisMC(kFALSE), + fAnalysisPbPb(kFALSE), + fTPCBranch(kFALSE), + ftrigBit1(0x0), + ftrigBit2(0x0), + fRandom(0x0), + fEvent(0x0), + fTrackArrayGlobalPar(0x0), + fTrackArrayMC(0x0), + fVtxCut(10.0), + fEtaCut(0.9), + fMinPt(0.1), + fLowPtFraction(0.01), + fTreeOption(0), + fMcProcessType(-999), + fTriggeredEventMB(-999), + fVtxStatus(-999), + fZvtx(-999), + fZvtxMC(-999), + fRun(-999), + fEventId(-999), + fListOfObjects(0), + fEvents(0x0), fVtx(0x0), fVtxMC(0x0), fVtxBeforeCuts(0x0), fVtxAfterCuts(0x0), + fTree(0x0), + fn1(0), + fn2(0), + fcent(0) + +{ + + if(fTree)fTree=0; + // Output slot #1 writes into a TList + DefineOutput(1, TList::Class()); +} + +//_____________________________________________________________________________ +AliAnalysisTaskHighPtDeDx::~AliAnalysisTaskHighPtDeDx() +{ + // Destructor + // histograms are in the output list and deleted when the output + // list is deleted by the TSelector dtor + if (fListOfObjects && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { + delete fListOfObjects; + fListOfObjects = 0; + } + if (fRandom) delete fRandom; + fRandom=0; + + // //for proof running; I cannot create tree do to memory limitations -> work with THnSparse + // if (fListOfObjects && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) delete fOutputList; + + + +} + +//______________________________________________________________________________ +void AliAnalysisTaskHighPtDeDx::UserCreateOutputObjects() +{ + // This method is called once per worker node + // Here we define the output: histograms and debug tree if requested + // We also create the random generator here so it might get different seeds... + fRandom = new TRandom(0); // 0 means random seed + + OpenFile(1); + fListOfObjects = new TList(); + fListOfObjects->SetOwner(); + + // + // Histograms + // + fEvents = new TH1I("fEvents","Number of analyzed events; Events; Counts", 3, 0, 3); + fListOfObjects->Add(fEvents); + + fn1=new TH1F("fn1","fn1",5001,-1,5000); + fListOfObjects->Add(fn1); + + fn2=new TH1F("fn2","fn2",5001,-1,5000); + fListOfObjects->Add(fn2); + + fcent=new TH1F("fcent","fcent",104,-2,102); + fListOfObjects->Add(fcent); + + fVtx = new TH1I("fVtx","Vtx info (0=no, 1=yes); Vtx; Counts", 2, -0.5, 1.5); + fListOfObjects->Add(fVtx); + + fVtxBeforeCuts = new TH1F("fVtxBeforeCuts", "Vtx distribution (before cuts); Vtx z [cm]; Counts", 120, -30, 30); + fListOfObjects->Add(fVtxBeforeCuts); + + fVtxAfterCuts = new TH1F("fVtxAfterCuts", "Vtx distribution (before cuts); Vtx z [cm]; Counts", 120, -30, 30); + fListOfObjects->Add(fVtxAfterCuts); + + if (fAnalysisMC) { + fVtxMC = new TH1I("fVtxMC","Vtx info - no trigger cut (0=no, 1=yes); Vtx; Counts", 2, -0.5, 1.5); + fListOfObjects->Add(fVtxMC); + } + + if (fTreeOption) { + + fTree = new TTree("tree","Event data"); + fEvent = new DeDxEvent(); + fTree->Branch("event", &fEvent); + + fTrackArrayGlobalPar = new TClonesArray("DeDxTrack", 1000); + fTree->Bronch("trackGlobalPar", "TClonesArray", &fTrackArrayGlobalPar); + if(fTPCBranch){ + fTrackArrayTPCPar = new TClonesArray("DeDxTrack", 1000); + fTree->Bronch("trackTPCPar", "TClonesArray", &fTrackArrayTPCPar); + } + + fVZEROArray = new TClonesArray("VZEROCell", 1000); + fTree->Bronch("cellVZERO", "TClonesArray", &fVZEROArray); + + if (fAnalysisMC) { + fTrackArrayMC = new TClonesArray("DeDxTrackMC", 1000); + fTree->Bronch("trackMC", "TClonesArray", &fTrackArrayMC); + } + + fTree->SetDirectory(0); + + fListOfObjects->Add(fTree); + + } + + // Post output data. + PostData(1, fListOfObjects); +} + +//______________________________________________________________________________ +void AliAnalysisTaskHighPtDeDx::UserExec(Option_t *) +{ + // Main loop + + // + // First we make sure that we have valid input(s)! + // + AliVEvent *event = InputEvent(); + if (!event) { + Error("UserExec", "Could not retrieve event"); + return; + } + + + if (fAnalysisType == "ESD"){ + fESD = dynamic_cast(event); + if(!fESD){ + Printf("%s:%d ESDEvent not found in Input Manager",(char*)__FILE__,__LINE__); + this->Dump(); + return; + } + } else { + fAOD = dynamic_cast(event); + if(!fAOD){ + Printf("%s:%d AODEvent not found in Input Manager",(char*)__FILE__,__LINE__); + this->Dump(); + return; + } + } + + + + if (fAnalysisMC) { + + if (fAnalysisType == "ESD"){ + fMC = dynamic_cast(MCEvent()); + if(!fMC){ + Printf("%s:%d MCEvent not found in Input Manager",(char*)__FILE__,__LINE__); + this->Dump(); + return; + } + + fMCStack = fMC->Stack(); + + if(!fMCStack){ + Printf("%s:%d MCStack not found in Input Manager",(char*)__FILE__,__LINE__); + this->Dump(); + return; + } + } else { // AOD + + fMC = dynamic_cast(MCEvent()); + if(fMC) + fMC->Dump(); + + fMCArray = (TClonesArray*)fAOD->FindListObject("mcparticles"); + if(!fMCArray){ + Printf("%s:%d AOD MC array not found in Input Manager",(char*)__FILE__,__LINE__); + this->Dump(); + return; + } + } + } + + + // Get trigger decision + fTriggeredEventMB = 0; //init + + + if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler())) + ->IsEventSelected() & ftrigBit1 ){ + fn1->Fill(1); + fTriggeredEventMB = 1; //event triggered as minimum bias + } + if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler())) + ->IsEventSelected() & ftrigBit2 ){ + // From AliVEvent: + // kINT7 = BIT(1), // V0AND trigger, offline V0 selection + fTriggeredEventMB += 2; + fn2->Fill(1); + } + + + // Get process type for MC + fMcProcessType = 0; // -1=invalid, 0=data, 1=ND, 2=SD, 3=DD + + // real data that are not triggered we skip + if(!fAnalysisMC && !fTriggeredEventMB) + return; + + if (fAnalysisMC) { + + if (fAnalysisType == "ESD"){ + + AliHeader* headerMC = fMC->Header(); + if (headerMC) { + + AliGenEventHeader* genHeader = headerMC->GenEventHeader(); + TArrayF vtxMC(3); // primary vertex MC + vtxMC[0]=9999; vtxMC[1]=9999; vtxMC[2]=9999; //initialize with dummy + if (genHeader) { + genHeader->PrimaryVertex(vtxMC); + } + fZvtxMC = vtxMC[2]; + + // PYTHIA: + AliGenPythiaEventHeader* pythiaGenHeader = + dynamic_cast(headerMC->GenEventHeader()); + if (pythiaGenHeader) { //works only for pythia + fMcProcessType = GetPythiaEventProcessType(pythiaGenHeader->ProcessType()); + } + // PHOJET: + AliGenDPMjetEventHeader* dpmJetGenHeader = + dynamic_cast(headerMC->GenEventHeader()); + if (dpmJetGenHeader) { + fMcProcessType = GetDPMjetEventProcessType(dpmJetGenHeader->ProcessType()); + } + } + } else { // AOD + + AliAODMCHeader* mcHeader = dynamic_cast(fAOD->FindListObject("mcHeader")); + if(mcHeader) { + fZvtxMC = mcHeader->GetVtxZ(); + + if(strstr(mcHeader->GetGeneratorName(), "Pythia")) { + fMcProcessType = GetPythiaEventProcessType(mcHeader->GetEventType()); + } else { + fMcProcessType = GetDPMjetEventProcessType(mcHeader->GetEventType()); + } + } + } + } + + // There are 3 cases + // Vertex: NO - status -1 + // Vertex: YES : outside cut - status 0 + // : inside cut - status 1 + // We have to be careful how we normalize because we probably want to + // normalize to: + // Nevents=(No vertex + outside + inside)/(out + in)*in + + + if (fAnalysisType == "ESD") + fZvtx = GetVertex(fESD); + else // AOD + fZvtx = GetVertex(fAOD); + + fVtxStatus = -999; + + if(fZvtx<-990) { + + fVtxStatus = -1; + if(fTriggeredEventMB) + fVtx->Fill(0); + if(fAnalysisMC) + fVtxMC->Fill(0); + } else { + + if(fTriggeredEventMB) + fVtx->Fill(1); + if(fAnalysisMC) + fVtxMC->Fill(1); + fVtxBeforeCuts->Fill(fZvtx); + fVtxStatus = 0; + if (TMath::Abs(fZvtx) < fVtxCut) { + fVtxAfterCuts->Fill(fZvtx); + fVtxStatus = 1; + } + } + + // store MC event data no matter what + if(fAnalysisMC) { + + if (fAnalysisType == "ESD") { + ProcessMCTruthESD(); + } else { // AOD + ProcessMCTruthAOD(); + } + } + + + + Float_t centrality = -10; + // only analyze triggered events + if(fTriggeredEventMB) { + + if (fAnalysisType == "ESD"){ + if(fAnalysisPbPb){ + AliCentrality *centObject = fESD->GetCentrality(); + centrality = centObject->GetCentralityPercentile("V0M"); + if((centrality>fMaxCent)||(centralityFill(centrality); + AnalyzeESD(fESD); + } else { // AOD + if(fAnalysisPbPb){ + AliCentrality *centObject = fAOD->GetCentrality(); + if(centObject) + centrality = centObject->GetCentralityPercentile("V0M"); + if((centrality>fMaxCent)||(centralityFill(centrality); + AnalyzeAOD(fAOD); + } + } + + if( fTreeOption) { + + fEvent->process = fMcProcessType; + fEvent->trig = fTriggeredEventMB; + fEvent->zvtxMC = fZvtxMC; + fEvent->cent = centrality; + + fTree->Fill(); + fTrackArrayGlobalPar->Clear(); + if(fTPCBranch) + fTrackArrayTPCPar->Clear(); + fVZEROArray->Clear(); + + if (fAnalysisMC) + fTrackArrayMC->Clear(); + } + + // Post output data. + PostData(1, fListOfObjects); +} + +//________________________________________________________________________ +void AliAnalysisTaskHighPtDeDx::AnalyzeESD(AliESDEvent* esdEvent) +{ + fRun = esdEvent->GetRunNumber(); + fEventId = 0; + if(esdEvent->GetHeader()) + fEventId = GetEventIdAsLong(esdEvent->GetHeader()); + + Short_t isPileup = esdEvent->IsPileupFromSPD(); + + // Int_t event = esdEvent->GetEventNumberInFile(); + UInt_t time = esdEvent->GetTimeStamp(); + // ULong64_t trigger = esdEvent->GetTriggerMask(); + Float_t magf = esdEvent->GetMagneticField(); + + + + + + if(fTriggeredEventMB) {// Only MC case can we have not triggered events + + // accepted event + fEvents->Fill(0); + + + if(fVtxStatus!=1) return; // accepted vertex + Int_t nESDTracks = esdEvent->GetNumberOfTracks(); + + if(nESDTracks<1)return; + cout<<"Multiplicity="<Fill(1); + AliESDVZERO *esdV0 = esdEvent->GetVZEROData();// loop sobre canales del V0 para obtener las multiplicidad + + for (Int_t iCh=0; iCh<64; ++iCh) { + Float_t multv=esdV0->GetMultiplicity(iCh); + Int_t intexv=iCh; + VZEROCell* cellv0 = new((*fVZEROArray)[iCh]) VZEROCell(); + cellv0->cellindex=intexv; + cellv0->cellmult= multv; + } + + + + } // end if triggered + + if(fTreeOption) { + + fEvent->run = fRun; + fEvent->eventid = fEventId; + fEvent->time = time; + //fEvent->cent = centrality; + fEvent->mag = magf; + fEvent->zvtx = fZvtx; + fEvent->vtxstatus = fVtxStatus; + fEvent->pileup = isPileup; + + } + + + + +} + +//________________________________________________________________________ +void AliAnalysisTaskHighPtDeDx::AnalyzeAOD(AliAODEvent* aodEvent) +{ + fRun = aodEvent->GetRunNumber(); + fEventId = 0; + if(aodEvent->GetHeader()) + fEventId = GetEventIdAsLong(aodEvent->GetHeader()); + + UInt_t time = 0; // Missing AOD info? aodEvent->GetTimeStamp(); + Float_t magf = aodEvent->GetMagneticField(); + + //Int_t trackmult = 0; // no pt cuts + //Int_t nadded = 0; + + Short_t isPileup = aodEvent->IsPileupFromSPD(); + + + + + if(fTriggeredEventMB) {// Only MC case can we have not triggered events + + // accepted event + fEvents->Fill(0); + + if(fVtxStatus!=1) return; // accepted vertex + Int_t nAODTracks = aodEvent->GetNumberOfTracks(); + if(nAODTracks<1)return; + + ProduceArrayTrksAOD( aodEvent, kGlobalTrk ); + if(fTPCBranch) + ProduceArrayTrksAOD( aodEvent, kTPCTrk ); + fEvents->Fill(1); + + AliAODVZERO *esdV0 = aodEvent->GetVZEROData();// loop sobre canales del V0 para obtener las multiplicidad + + for (Int_t iCh=0; iCh<64; ++iCh) { + Float_t multv=esdV0->GetMultiplicity(iCh); + Int_t intexv=iCh; + VZEROCell* cellv0 = new((*fVZEROArray)[iCh]) VZEROCell(); + cellv0->cellindex=intexv; + cellv0->cellmult= multv; + } + + + + + } // end if triggered + + if(fTreeOption) { + + //Sort(fTrackArrayGlobalPar, kFALSE); + + fEvent->run = fRun; + fEvent->eventid = fEventId; + fEvent->time = time; + //fEvent->cent = centrality; + fEvent->mag = magf; + fEvent->zvtx = fZvtx; + fEvent->vtxstatus = fVtxStatus; + //fEvent->trackmult = trackmult; + //fEvent->n = nadded; + fEvent->pileup = isPileup; + } +} + +//_____________________________________________________________________________ +Float_t AliAnalysisTaskHighPtDeDx::GetVertex(const AliVEvent* event) const +{ + Float_t zvtx = -999; + + const AliVVertex* primaryVertex = event->GetPrimaryVertex(); + + if(primaryVertex->GetNContributors()>0) + zvtx = primaryVertex->GetZ(); + + return zvtx; +} + +//_____________________________________________________________________________ +Short_t AliAnalysisTaskHighPtDeDx::GetPidCode(Int_t pdgCode) const +{ + // return our internal code for pions, kaons, and protons + + Short_t pidCode = 6; + + switch (TMath::Abs(pdgCode)) { + case 211: + pidCode = 1; // pion + break; + case 321: + pidCode = 2; // kaon + break; + case 2212: + pidCode = 3; // proton + break; + case 11: + pidCode = 4; // electron + break; + case 13: + pidCode = 5; // muon + break; + default: + pidCode = 6; // something else? + }; + + return pidCode; +} + + +//_____________________________________________________________________________ +void AliAnalysisTaskHighPtDeDx::ProcessMCTruthESD() +{ + // Fill the special MC histogram with the MC truth info + + Short_t trackmult = 0; + Short_t nadded = 0; + const Int_t nTracksMC = fMCStack->GetNtrack(); + + for (Int_t iTracks = 0; iTracks < nTracksMC; iTracks++) { + + //Cuts + if(!(fMCStack->IsPhysicalPrimary(iTracks))) + continue; + + TParticle* trackMC = fMCStack->Particle(iTracks); + + Double_t chargeMC = trackMC->GetPDG()->Charge(); + if (chargeMC == 0) + continue; + + if (TMath::Abs(trackMC->Eta()) > fEtaCut ) + continue; + + trackmult++; + + // "charge:pt:p:eta:phi:pidCode" + Float_t ptMC = trackMC->Pt(); + Float_t pMC = trackMC->P(); + Float_t etaMC = trackMC->Eta(); + Float_t phiMC = trackMC->Phi(); + + Int_t pdgCode = trackMC->GetPdgCode(); + Short_t pidCodeMC = 0; + pidCodeMC = GetPidCode(pdgCode); + + // Here we want to add some of the MC histograms! + + // And therefore we first cut here! + if (trackMC->Pt() < fMinPt) { + + // Keep small fraction of low pT tracks + if(fRandom->Rndm() > fLowPtFraction) + continue; + } // else { + // Here we want to add the high pt part of the MC histograms! + // } + + if(fTreeOption) { + + DeDxTrackMC* track = new((*fTrackArrayMC)[nadded]) DeDxTrackMC(); + nadded++; + + track->pMC = pMC; + track->ptMC = ptMC; + track->etaMC = etaMC; + track->phiMC = phiMC; + track->qMC = Short_t(chargeMC); + track->pidMC = pidCodeMC; + track->pdgMC = pdgCode; + } + + }//MC track loop + + if(fTreeOption) { + + Sort(fTrackArrayMC, kTRUE); + + fEvent->trackmultMC = trackmult; + fEvent->nMC = nadded; + } + +} + +//_____________________________________________________________________________ +void AliAnalysisTaskHighPtDeDx::ProcessMCTruthAOD() +{ + // Fill the special MC histogram with the MC truth info + + Short_t trackmult = 0; + Short_t nadded = 0; + const Int_t nTracksMC = fMCArray->GetEntriesFast(); + + for (Int_t iTracks = 0; iTracks < nTracksMC; iTracks++) { + + AliAODMCParticle* trackMC = dynamic_cast(fMCArray->At(iTracks)); + + //Cuts + if(!(trackMC->IsPhysicalPrimary())) + continue; + + + Double_t chargeMC = trackMC->Charge(); + if (chargeMC == 0) + continue; + + if (TMath::Abs(trackMC->Eta()) > fEtaCut ) + continue; + + trackmult++; + + // "charge:pt:p:eta:phi:pidCode" + Float_t ptMC = trackMC->Pt(); + Float_t pMC = trackMC->P(); + Float_t etaMC = trackMC->Eta(); + Float_t phiMC = trackMC->Phi(); + + Int_t pdgCode = trackMC->PdgCode(); + Short_t pidCodeMC = 0; + pidCodeMC = GetPidCode(pdgCode); + + // Here we want to add some of the MC histograms! + + // And therefore we first cut here! + if (trackMC->Pt() < fMinPt) { + + // Keep small fraction of low pT tracks + if(fRandom->Rndm() > fLowPtFraction) + continue; + } // else { + // Here we want to add the high pt part of the MC histograms! + // } + + if(fTreeOption) { + + DeDxTrackMC* track = new((*fTrackArrayMC)[nadded]) DeDxTrackMC(); + nadded++; + + track->pMC = pMC; + track->ptMC = ptMC; + track->etaMC = etaMC; + track->phiMC = phiMC; + track->qMC = Short_t(chargeMC); + track->pidMC = pidCodeMC; + track->pdgMC = pdgCode; + } + + }//MC track loop + + if(fTreeOption) { + + Sort(fTrackArrayMC, kTRUE); + + fEvent->trackmultMC = trackmult; + fEvent->nMC = nadded; + } + +} + +//_____________________________________________________________________________ +Short_t AliAnalysisTaskHighPtDeDx::GetPythiaEventProcessType(Int_t pythiaType) { + // + // Get the process type of the event. PYTHIA + // + // source PWG0 dNdpt + + Short_t globalType = -1; //init + + if(pythiaType==92||pythiaType==93){ + globalType = 2; //single diffractive + } + else if(pythiaType==94){ + globalType = 3; //double diffractive + } + //else if(pythiaType != 91){ // also exclude elastic to be sure... CKB?? + else { + globalType = 1; //non diffractive + } + return globalType; +} + +//_____________________________________________________________________________ +Short_t AliAnalysisTaskHighPtDeDx::GetDPMjetEventProcessType(Int_t dpmJetType) { + // + // get the process type of the event. PHOJET + // + //source PWG0 dNdpt + // can only read pythia headers, either directly or from cocktalil header + Short_t globalType = -1; + + if (dpmJetType == 1 || dpmJetType == 4) { // explicitly inelastic plus central diffraction + globalType = 1; + } + else if (dpmJetType==5 || dpmJetType==6) { + globalType = 2; + } + else if (dpmJetType==7) { + globalType = 3; + } + return globalType; +} + +//_____________________________________________________________________________ +ULong64_t AliAnalysisTaskHighPtDeDx::GetEventIdAsLong(AliVHeader* header) const +{ + // To have a unique id for each event in a run! + // Modified from AliRawReader.h + return ((ULong64_t)header->GetBunchCrossNumber()+ + (ULong64_t)header->GetOrbitNumber()*3564+ + (ULong64_t)header->GetPeriodNumber()*16777215*3564); +} + + +//____________________________________________________________________ +TParticle* AliAnalysisTaskHighPtDeDx::FindPrimaryMother(AliStack* stack, Int_t label) +{ + // + // Finds the first mother among the primary particles of the particle identified by