]>
Commit | Line | Data |
---|---|---|
fb65de21 | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | ///////////////////////////////////////////////////// | |
17 | // | |
18 | // Check basic detector results at ESD level | |
19 | // - Geometrical efficiency | |
20 | // - Tracking efficiency | |
21 | // - PID efficiency | |
22 | // - Refit efficiency | |
23 | // | |
24 | // Author | |
25 | // Alex Bercuci <A.Bercuci@gsi.de> | |
26 | // | |
27 | ////////////////////////////////////////////////////// | |
28 | ||
29 | #include <TClonesArray.h> | |
30 | #include <TCanvas.h> | |
31 | #include <TObjArray.h> | |
32 | #include <TPad.h> | |
33 | #include <TLegend.h> | |
34 | #include <TLatex.h> | |
35 | #include <TLine.h> | |
36 | #include <TF1.h> | |
7698e7a4 | 37 | #include <TH1D.h> |
38 | #include <TH2D.h> | |
39 | #include <TH3D.h> | |
fb65de21 | 40 | #include <TH2I.h> |
41 | #include <TH2F.h> | |
42 | #include <TH3S.h> | |
43 | #include <TH3F.h> | |
44 | #include <TProfile2D.h> | |
45 | #include <TProfile.h> | |
46 | #include <TGraphErrors.h> | |
47 | #include <TGraphAsymmErrors.h> | |
48 | #include <TFile.h> | |
49 | #include <TTree.h> | |
50 | #include <TROOT.h> | |
51 | #include <TChain.h> | |
52 | #include <TParticle.h> | |
53 | #include <TTimeStamp.h> | |
7698e7a4 | 54 | #include <TRandom.h> |
fb65de21 | 55 | |
56 | #include "AliLog.h" | |
57 | #include "AliAnalysisManager.h" | |
7698e7a4 | 58 | #include "AliAnalysisCuts.h" |
fb65de21 | 59 | #include "AliESDEvent.h" |
60 | #include "AliESDkink.h" | |
61 | #include "AliMCEvent.h" | |
62 | #include "AliESDInputHandler.h" | |
63 | #include "AliMCEventHandler.h" | |
64 | #include "AliESDpid.h" | |
65 | ||
66 | #include "AliESDtrack.h" | |
67 | #include "AliMCParticle.h" | |
68 | #include "AliPID.h" | |
69 | #include "AliStack.h" | |
70 | #include "AliTrackReference.h" | |
2bf6d80c | 71 | //#include "AliESDCentrality.h" |
72 | #include "AliMultiplicity.h" | |
7698e7a4 | 73 | #include "AliCFContainer.h" |
fb65de21 | 74 | |
75 | #include "AliTRDcheckESD.h" | |
2bf6d80c | 76 | #include <iostream> |
77 | using namespace std; | |
fb65de21 | 78 | |
79 | ClassImp(AliTRDcheckESD) | |
80 | ||
81 | const Float_t AliTRDcheckESD::fgkxTPC = 290.; | |
82 | const Float_t AliTRDcheckESD::fgkxTOF = 365.; | |
83 | const UChar_t AliTRDcheckESD::fgkNgraph[AliTRDcheckESD::kNrefs] ={ | |
84 | 8, 4, 2, 20}; | |
85 | FILE* AliTRDcheckESD::fgFile = NULL; | |
86 | ||
87 | const Float_t AliTRDcheckESD::fgkEvVertexZ = 15.; | |
88 | const Int_t AliTRDcheckESD::fgkEvVertexN = 1; | |
89 | const Float_t AliTRDcheckESD::fgkTrkDCAxy = 40.; | |
90 | const Float_t AliTRDcheckESD::fgkTrkDCAz = 15.; | |
91 | const Int_t AliTRDcheckESD::fgkNclTPC = 100; | |
92 | const Float_t AliTRDcheckESD::fgkPt = 0.2; | |
93 | const Float_t AliTRDcheckESD::fgkEta = 0.9; | |
94 | const Float_t AliTRDcheckESD::fgkQs = 0.002; | |
95 | ||
96 | //____________________________________________________________________ | |
97 | AliTRDcheckESD::AliTRDcheckESD(): | |
98 | AliAnalysisTaskSE() | |
99 | ,fStatus(0) | |
100 | ,fNRefFigures(0) | |
101 | ,fESD(NULL) | |
102 | ,fMC(NULL) | |
103 | ,fESDpid(new AliESDpid) | |
104 | ,fHistos(NULL) | |
105 | ,fResults(NULL) | |
7698e7a4 | 106 | ,fCfContainer(NULL) |
107 | ,fReferenceTrackFilter(NULL) | |
fb65de21 | 108 | { |
109 | // | |
110 | // Default constructor | |
111 | // | |
112 | SetNameTitle("TRDcheckESD", "Check TRD @ ESD level"); | |
113 | SetMC(kTRUE); | |
114 | } | |
115 | ||
116 | //____________________________________________________________________ | |
117 | AliTRDcheckESD::AliTRDcheckESD(char* name): | |
118 | AliAnalysisTaskSE(name) | |
119 | ,fStatus(0) | |
120 | ,fNRefFigures(0) | |
121 | ,fESD(NULL) | |
122 | ,fMC(NULL) | |
123 | ,fESDpid(new AliESDpid) | |
124 | ,fHistos(NULL) | |
125 | ,fResults(NULL) | |
7698e7a4 | 126 | ,fCfContainer(NULL) |
127 | ,fReferenceTrackFilter(NULL) | |
fb65de21 | 128 | { |
129 | // | |
130 | // Default constructor | |
131 | // | |
132 | SetMC(kTRUE); | |
133 | SetTitle("Check TRD @ ESD level"); | |
134 | DefineOutput(1, TObjArray::Class()); | |
135 | } | |
136 | ||
137 | //____________________________________________________________________ | |
138 | AliTRDcheckESD::~AliTRDcheckESD() | |
139 | { | |
140 | // Destructor | |
76dfbc0e | 141 | if(fHistos && !(AliAnalysisManager::GetAnalysisManager() && AliAnalysisManager::GetAnalysisManager()->IsProofMode())){ |
142 | if(fHistos->IsOwner()) fHistos->Delete(); | |
fb65de21 | 143 | delete fHistos; |
76dfbc0e | 144 | fHistos = NULL; |
fb65de21 | 145 | } |
146 | if(fResults){ | |
147 | fResults->Delete(); | |
148 | delete fResults; | |
149 | } | |
150 | } | |
151 | ||
152 | //____________________________________________________________________ | |
153 | void AliTRDcheckESD::UserCreateOutputObjects() | |
154 | { | |
155 | // | |
156 | // Create Output Containers (TObjectArray containing 1D histograms) | |
157 | // | |
158 | Histos(); | |
159 | PostData(1, fHistos); | |
160 | } | |
161 | ||
7698e7a4 | 162 | //____________________________________________________________________ |
33d501fa | 163 | void AliTRDcheckESD::MakeSummaryFromCF(Double_t* trendValues, Bool_t useIsolatedBC, Bool_t cutTOFbc){ |
7698e7a4 | 164 | // |
165 | // Draw summary plots for the ESDcheck task using the CF container | |
166 | // | |
167 | ||
33d501fa | 168 | cout << "Make summary from CF" << endl; |
7698e7a4 | 169 | TCanvas *cOut=0x0; |
33d501fa | 170 | if(gROOT->FindObject("trackingSummary")) delete gROOT->FindObject("trackingSummary"); |
7698e7a4 | 171 | cOut = new TCanvas("trackingSummary", "Tracking summary for the ESD task", 1600, 1200); |
172 | cOut->cd(); | |
33d501fa | 173 | PlotTrackingSummaryFromCF(0, trendValues, useIsolatedBC, cutTOFbc); |
7698e7a4 | 174 | cOut->SaveAs("trackingSummary.gif"); |
175 | ||
33d501fa | 176 | if(gROOT->FindObject("pidSummary")) delete gROOT->FindObject("pidSummary"); |
7698e7a4 | 177 | cOut = new TCanvas("pidSummary", "PID summary for the ESD task", 1600, 1200); |
178 | cOut->cd(); | |
179 | //GetRefFigure(6); | |
33d501fa | 180 | PlotPidSummaryFromCF(0, trendValues, useIsolatedBC, cutTOFbc); |
7698e7a4 | 181 | cOut->SaveAs("pidSummary.gif"); |
182 | ||
33d501fa | 183 | if(gROOT->FindObject("centSummary")) delete gROOT->FindObject("centSummary"); |
7698e7a4 | 184 | cOut = new TCanvas("centSummary", "Centrality summary for the ESD task", 1600, 1200); |
185 | cOut->cd(); | |
186 | //GetRefFigure(7); | |
33d501fa | 187 | PlotCentSummaryFromCF(trendValues, useIsolatedBC, cutTOFbc); |
7698e7a4 | 188 | cOut->SaveAs("centSummary.gif"); |
189 | ||
190 | } | |
191 | ||
192 | ||
fb65de21 | 193 | //____________________________________________________________________ |
33d501fa | 194 | void AliTRDcheckESD::MakeSummary(Double_t* trendValues){ |
fb65de21 | 195 | // |
196 | // Draw summary plots for the ESDcheck task | |
197 | // | |
33d501fa | 198 | // Old method to draw summary pictures from histograms. Use the MakeSummaryFromCF() when CF container is present |
2bf6d80c | 199 | |
33d501fa | 200 | cout << "Make summary" << endl; |
201 | TCanvas *cTracking=0x0; | |
202 | if(gROOT->FindObject("trackingSummary")) delete gROOT->FindObject("trackingSummary"); | |
203 | cTracking = new TCanvas("trackingSummary", "Tracking summary for the ESD task", 1600, 1200); | |
204 | cTracking->cd(); | |
205 | //GetRefFigure(5); | |
206 | if(PlotTrackingSummary(0, trendValues)) | |
207 | cTracking->SaveAs("trackingSummary.gif"); | |
2bf6d80c | 208 | |
33d501fa | 209 | TCanvas* cPid = 0x0; |
210 | if(gROOT->FindObject("pidSummary")) delete gROOT->FindObject("pidSummary"); | |
211 | cPid = new TCanvas("pidSummary", "PID summary for the ESD task", 1600, 1200); | |
212 | cPid->cd(); | |
213 | //GetRefFigure(6); | |
214 | if(PlotPidSummary(0, trendValues)) | |
215 | cPid->SaveAs("pidSummary.gif"); | |
2bf6d80c | 216 | |
33d501fa | 217 | TCanvas* cCent=0x0; |
218 | if(gROOT->FindObject("centSummary")) delete gROOT->FindObject("centSummary"); | |
219 | cCent = new TCanvas("centSummary", "Centrality summary for the ESD task", 1600, 1200); | |
220 | cCent->cd(); | |
221 | //GetRefFigure(7); | |
222 | if(PlotCentSummary(trendValues)) | |
223 | cCent->SaveAs("centSummary.gif"); | |
fb65de21 | 224 | } |
225 | ||
226 | //____________________________________________________________________ | |
227 | Bool_t AliTRDcheckESD::GetRefFigure(Int_t ifig) | |
228 | { | |
229 | // | |
230 | // Produce reference Plots during PostProcessing | |
231 | // | |
232 | if(ifig>=fNRefFigures){ | |
233 | AliWarning(Form("Ref plot %d not available. Valid only up to %d", ifig, fNRefFigures)); | |
234 | return kFALSE; | |
235 | } | |
236 | if(!gPad){ | |
237 | AliWarning("Please provide a canvas to draw results."); | |
238 | return kFALSE; | |
239 | } else { | |
240 | gPad->SetLogx(0);gPad->SetLogy(0); | |
241 | gPad->SetMargin(0.125, 0.015, 0.1, 0.015); | |
242 | } | |
243 | ||
244 | const Char_t *title[20]; | |
fb65de21 | 245 | TH1 *hF(NULL); |
fb65de21 | 246 | if((hF=(TH1S*)gROOT->FindObject("hFcheckESD"))) delete hF; |
247 | TLegend *leg(NULL); | |
248 | TList *l(NULL); TVirtualPad *pad(NULL); | |
249 | TGraphErrors *g(NULL);TGraphAsymmErrors *ga(NULL); | |
250 | TObjArray *arr(NULL); | |
fb65de21 | 251 | TLatex *lat=new TLatex(); |
252 | lat->SetTextSize(0.07); | |
253 | lat->SetTextColor(2); | |
254 | TLine line; | |
255 | TTimeStamp now; | |
fb65de21 | 256 | switch(ifig){ |
257 | case kNCl: // number of clusters/track | |
258 | if(!(arr = (TObjArray*)fResults->At(kNCl))) return kFALSE; | |
259 | ||
260 | leg = new TLegend(.83, .7, .99, .96); | |
261 | leg->SetHeader("Species"); | |
262 | leg->SetBorderSize(0); leg->SetFillStyle(0); | |
2bf6d80c | 263 | for(Int_t ig(0); ig<fgkNgraph[kNCl-1]; ig++){ |
fb65de21 | 264 | if(!(g = (TGraphErrors*)arr->At(ig))) return kFALSE; |
265 | if(!g->GetN()) continue; | |
266 | g->Draw(ig?"pc":"apc"); leg->AddEntry(g, g->GetTitle(), "pl"); | |
267 | if(ig) continue; | |
268 | hF=g->GetHistogram(); | |
269 | hF->SetXTitle("no of clusters"); | |
270 | hF->SetYTitle("entries"); | |
271 | hF->GetYaxis()->CenterTitle(1); | |
272 | hF->GetYaxis()->SetTitleOffset(1.2); | |
273 | hF->SetMinimum(5); | |
274 | } | |
275 | leg->Draw(); gPad->SetLogy(); | |
276 | break; | |
277 | case kTRDstat: // Efficiency | |
278 | if(!(arr = (TObjArray*)fResults->At(kTRDstat))) return kFALSE; | |
279 | leg = new TLegend(.62, .77, .98, .98); | |
280 | leg->SetHeader("TRD Efficiency"); | |
281 | leg->SetBorderSize(0); leg->SetFillStyle(0); | |
282 | title[0] = "Geometrical (TRDin/TPCout)"; | |
283 | title[1] = "Tracking (TRDout/TRDin)"; | |
284 | title[2] = "PID (TRDpid/TRDin)"; | |
285 | title[3] = "Refit (TRDrefit/TRDin)"; | |
286 | hF = new TH1S("hFcheckESD", ";p [GeV/c];Efficiency", 10, 0.1, 10.); | |
287 | hF->SetMaximum(1.4); | |
288 | hF->GetXaxis()->SetMoreLogLabels(); | |
289 | hF->GetYaxis()->CenterTitle(1); | |
290 | hF->Draw("p"); | |
2bf6d80c | 291 | for(Int_t ig(0); ig<fgkNgraph[kTRDstat-1]; ig++){ |
fb65de21 | 292 | if(!(g = (TGraphErrors*)arr->At(ig))) return kFALSE; |
293 | g->Draw("pl"); leg->AddEntry(g, title[ig], "pl"); | |
294 | //PutTrendValue(name[id], g->GetMean(2)); | |
295 | //PutTrendValue(Form("%sRMS", name[id]), g->GetRMS(2)); | |
296 | } | |
297 | leg->Draw(); gPad->SetLogx(); | |
298 | break; | |
299 | case kTRDmom: // Energy loss | |
300 | if(!(arr = (TObjArray*)fResults->At(kTRDmom))) return kFALSE; | |
301 | leg = new TLegend(.65, .7, .95, .99); | |
302 | leg->SetHeader("Energy Loss"); | |
303 | leg->SetBorderSize(1); leg->SetFillColor(0); | |
304 | title[0] = "Max & 90% quantile"; | |
305 | title[1] = "Mean & 60% quantile"; | |
306 | hF = new TH1S("hFcheckESD", ";layer;#Delta E", 6, -0.5, 5.5); | |
307 | hF->SetMaximum(1.3);hF->SetMinimum(-.3); | |
308 | hF->Draw("p"); | |
2bf6d80c | 309 | for(Int_t ig(0); ig<fgkNgraph[kTRDmom-1]; ig++){ |
fb65de21 | 310 | if(!(ga = (TGraphAsymmErrors*)arr->At(ig))) return kFALSE; |
311 | ga->Draw("pl"); leg->AddEntry(ga, title[ig], "pl"); | |
312 | //PutTrendValue(name[id], g->GetMean(2)); | |
313 | //PutTrendValue(Form("%sRMS", name[id]), g->GetRMS(2)); | |
314 | } | |
315 | leg->Draw();gPad->SetLogx(kFALSE); | |
316 | break; | |
317 | case kPtRes: // Pt resolution @ vertex | |
318 | if(!(arr = (TObjArray*)fResults->At(kPtRes))) return kFALSE; | |
319 | gPad->Divide(2, 1, 1.e-5, 1.e-5); l=gPad->GetListOfPrimitives(); | |
320 | pad = ((TVirtualPad*)l->At(0)); pad->cd(); pad->SetLogx(); | |
321 | pad->SetMargin(0.1, 0.022, 0.1, 0.023); | |
322 | hF = new TH1S("hFcheckESD", "ITS+TPC+TRD;p_{t} [GeV/c];#Delta p_{t} / p_{t} [%]", 10, 0.2, 10.); | |
323 | hF->SetMaximum(10.);hF->SetMinimum(-3.); | |
324 | hF->GetXaxis()->SetMoreLogLabels(); | |
325 | hF->GetXaxis()->SetTitleOffset(1.2); | |
326 | hF->GetYaxis()->CenterTitle(); | |
327 | hF->Draw("p"); | |
2bf6d80c | 328 | //for(Int_t ig(0); ig<fgkNgraph[kPtRes-1]/2; ig++){ |
fb65de21 | 329 | for(Int_t ig(2); ig<6; ig++){ |
330 | if(!(g = (TGraphErrors*)arr->At(ig))) continue; | |
331 | if(!g->GetN()) continue; | |
332 | g->Draw("pl"); | |
333 | //PutTrendValue(name[id], g->GetMean(2)); | |
334 | //PutTrendValue(Form("%sRMS", name[id]), g->GetRMS(2)); | |
335 | } | |
336 | pad = ((TVirtualPad*)l->At(1)); pad->cd(); pad->SetLogx(); | |
337 | pad->SetMargin(0.1, 0.22, 0.1, 0.023); | |
338 | hF = (TH1*)hF->Clone("hFcheckESD1"); | |
339 | hF->SetTitle("ITS+TPC"); | |
340 | hF->SetMaximum(10.);hF->SetMinimum(-3.); | |
341 | hF->Draw("p"); | |
342 | leg = new TLegend(.78, .1, .99, .98); | |
343 | leg->SetHeader("P_{t} @ DCA"); | |
344 | leg->SetBorderSize(1); leg->SetFillColor(0); | |
345 | leg->SetTextAlign(22); | |
346 | leg->SetTextFont(12); | |
347 | leg->SetTextSize(0.03813559); | |
348 | { | |
349 | Int_t nPlots(0); | |
2bf6d80c | 350 | //for(Int_t ig(fgkNgraph[kPtRes-1]/2); ig<fgkNgraph[kPtRes-1]; ig++){ |
fb65de21 | 351 | for(Int_t ig(12); ig<16; ig++){ |
352 | if(!(g = (TGraphErrors*)arr->At(ig))) continue; | |
353 | if(!g->GetN()) continue; | |
354 | nPlots++; | |
355 | g->Draw("pl"); leg->AddEntry(g, g->GetTitle(), "pl"); | |
356 | //PutTrendValue(name[id], g->GetMean(2)); | |
357 | //PutTrendValue(Form("%sRMS", name[id]), g->GetRMS(2)); | |
358 | } | |
359 | if(nPlots) leg->Draw(); | |
360 | } | |
361 | break; | |
2bf6d80c | 362 | case 5: // plot a 3x3 canvas with tracking related histograms |
363 | PlotTrackingSummary(0); | |
364 | break; | |
fb65de21 | 365 | |
2bf6d80c | 366 | case 6: // plot a 3x3 canvas with PID related histograms |
367 | PlotPidSummary(0); | |
fb65de21 | 368 | break; |
2bf6d80c | 369 | |
370 | case 7: // plot a 3x3 canvas with centrality dependence histograms | |
371 | PlotCentSummary(); | |
372 | break; | |
373 | ||
fb65de21 | 374 | } |
375 | return kTRUE; | |
376 | } | |
377 | ||
378 | //____________________________________________________________________ | |
379 | void AliTRDcheckESD::UserExec(Option_t *){ | |
380 | // | |
381 | // Run the Analysis | |
382 | // | |
383 | fESD = dynamic_cast<AliESDEvent*>(InputEvent()); | |
384 | fMC = MCEvent(); | |
385 | ||
386 | if(!fESD){ | |
387 | AliError("ESD event missing."); | |
388 | return; | |
389 | } | |
390 | ||
391 | // Get MC information if available | |
392 | AliStack * fStack = NULL; | |
393 | if(HasMC()){ | |
394 | if(!fMC){ | |
395 | AliWarning("MC event missing"); | |
396 | SetMC(kFALSE); | |
397 | } else { | |
398 | if(!(fStack = fMC->Stack())){ | |
399 | AliWarning("MC stack missing"); | |
400 | SetMC(kFALSE); | |
401 | } | |
402 | } | |
403 | } | |
404 | TH1 *h(NULL); | |
405 | ||
7698e7a4 | 406 | Double_t values[kNTrdCfVariables]; // array where the CF container variables are stored |
407 | values[kEventVtxZ] = fESD->GetPrimaryVertex()->GetZv(); | |
408 | values[kEventBC] = fESD->GetBunchCrossNumber(); | |
409 | ||
2bf6d80c | 410 | const AliMultiplicity* mult=fESD->GetMultiplicity(); |
411 | Double_t itsNTracklets = mult->GetNumberOfTracklets(); | |
2bf6d80c | 412 | if(itsNTracklets<1) return; |
7698e7a4 | 413 | Int_t multLimits[6] = {0, 700, 1400, 2100, 2800, 3500}; |
2bf6d80c | 414 | Int_t centralityClass = 0; |
7698e7a4 | 415 | for(Int_t iCent=0; iCent<5; ++iCent) { |
416 | if(itsNTracklets>=multLimits[iCent] && itsNTracklets<multLimits[iCent+1]) | |
417 | centralityClass=iCent+1; | |
2bf6d80c | 418 | } |
7698e7a4 | 419 | values[kEventMult] = itsNTracklets; |
2bf6d80c | 420 | if(centralityClass == 0) return; |
7698e7a4 | 421 | |
fb65de21 | 422 | AliESDtrack *esdTrack(NULL); |
423 | for(Int_t itrk = 0; itrk < fESD->GetNumberOfTracks(); itrk++){ | |
424 | esdTrack = fESD->GetTrack(itrk); | |
7698e7a4 | 425 | if(!fReferenceTrackFilter->IsSelected(esdTrack)) continue; |
fb65de21 | 426 | |
7698e7a4 | 427 | ULong_t status = esdTrack->GetStatus(); //PrintStatus(status); |
428 | ||
fb65de21 | 429 | // pid quality |
430 | Bool_t kBarrel = Bool_t(status & AliESDtrack::kTRDin); | |
431 | ||
fb65de21 | 432 | // find position and momentum of the track at entrance in TRD |
433 | Double_t localCoord[3] = {0., 0., 0.}; | |
434 | Bool_t localCoordGood = esdTrack->GetXYZAt(298., fESD->GetMagneticField(), localCoord); | |
fb65de21 | 435 | Double_t localMom[3] = {0., 0., 0.}; |
436 | Bool_t localMomGood = esdTrack->GetPxPyPzAt(298., fESD->GetMagneticField(), localMom); | |
7698e7a4 | 437 | //Double_t localPhi = (localMomGood ? TMath::ATan2(localMom[1], localMom[0]) : 0.0); |
fb65de21 | 438 | Double_t localSagitaPhi = (localCoordGood ? TMath::ATan2(localCoord[1], localCoord[0]) : 0.0); |
439 | ||
7698e7a4 | 440 | values[kTrackTOFdeltaBC] = esdTrack->GetTOFDeltaBC(); |
33d501fa | 441 | values[kTrackTOFBC] = esdTrack->GetTOFBunchCrossing(fESD->GetMagneticField()); |
442 | Float_t dcaXY=0.0; Float_t dcaZ=0.0; | |
443 | esdTrack->GetImpactParameters(dcaXY, dcaZ); | |
444 | values[kTrackDCAxy] = dcaXY; | |
445 | values[kTrackDCAz] = dcaZ; | |
7698e7a4 | 446 | values[kTrackCharge] = esdTrack->Charge(); |
447 | values[kTrackPhi] = localSagitaPhi; | |
448 | values[kTrackEta] = esdTrack->Eta(); | |
449 | values[kTrackPt] = esdTrack->Pt(); | |
450 | values[kTrackP] = esdTrack->P(); | |
451 | values[kTrackTrdTracklets] = esdTrack->GetTRDntracklets(); | |
452 | values[kTrackTrdClusters] = esdTrack->GetTRDncls(); | |
453 | for(Int_t i=0; i<6; ++i) values[kTrackQtot+i] = 0.0; | |
fb65de21 | 454 | |
7698e7a4 | 455 | if(localCoordGood && localMomGood) fCfContainer->Fill(values, 0); // fill the TPC reference step |
456 | ||
fb65de21 | 457 | // TRD reference tracks |
7698e7a4 | 458 | if(esdTrack->GetTRDntracklets()>=1) { |
fb65de21 | 459 | // (slicePH,sliceNo) distribution and Qtot from slices |
460 | for(Int_t iPlane=0; iPlane<6; iPlane++) { | |
2bf6d80c | 461 | Float_t qtot=esdTrack->GetTRDslice(iPlane, 0); |
7698e7a4 | 462 | for(Int_t iSlice=0; iSlice<8; iSlice++) { |
fb65de21 | 463 | if(esdTrack->GetTRDslice(iPlane, iSlice)>20.) { |
464 | h = (TH2F*)fHistos->At(kPHSlice); h->Fill(iSlice, esdTrack->GetTRDslice(iPlane, iSlice)); | |
2bf6d80c | 465 | h = (TH2F*)fHistos->At(kPHSlice+centralityClass); h->Fill(iSlice, esdTrack->GetTRDslice(iPlane, iSlice)); |
fb65de21 | 466 | } |
fb65de21 | 467 | } |
7698e7a4 | 468 | values[kTrackQtot+iPlane] = fgkQs*qtot; |
469 | } | |
470 | ||
471 | if(localCoordGood && localMomGood) { | |
472 | fCfContainer->Fill(values, 1); | |
473 | if(Bool_t(status & AliESDtrack::kTOFpid)) fCfContainer->Fill(values, 2); | |
fb65de21 | 474 | } |
fb65de21 | 475 | } // end if nTRDtrkl>=1 |
476 | ||
477 | // look at external track param | |
478 | const AliExternalTrackParam *op = esdTrack->GetOuterParam(); | |
479 | const AliExternalTrackParam *ip = esdTrack->GetInnerParam(); | |
480 | ||
7698e7a4 | 481 | Double_t pt(0.), pt0(0.), ptTRD(0.); |
fb65de21 | 482 | // read MC info if available |
483 | Bool_t kFOUND(kFALSE), kPhysPrim(kFALSE); | |
484 | AliMCParticle *mcParticle(NULL); | |
485 | if(HasMC()){ | |
486 | AliTrackReference *ref(NULL); | |
487 | Int_t fLabel(esdTrack->GetLabel()); | |
488 | Int_t fIdx(TMath::Abs(fLabel)); | |
7fe4e88b | 489 | if(!fStack || fIdx > fStack->GetNtrack()) continue; |
fb65de21 | 490 | |
491 | // read MC particle | |
492 | if(!(mcParticle = (AliMCParticle*) fMC->GetTrack(fIdx))) { | |
493 | AliWarning(Form("MC particle missing. Label[ %d].", fLabel)); | |
494 | continue; | |
495 | } | |
7698e7a4 | 496 | |
497 | pt = esdTrack->Pt(); | |
fb65de21 | 498 | pt0 = mcParticle->Pt(); |
7698e7a4 | 499 | //Double_t eta0 = mcParticle->Eta(); |
500 | //Double_t phi0 = mcParticle->Phi(); | |
fb65de21 | 501 | kPhysPrim = fMC->IsPhysicalPrimary(fIdx); |
502 | ||
503 | // read track references | |
504 | Int_t nRefs = mcParticle->GetNumberOfTrackReferences(); | |
505 | if(!nRefs){ | |
506 | AliWarning(Form("No TR found for track @ Label[%d].", fLabel)); | |
507 | continue; | |
508 | } | |
509 | Int_t iref = 0; | |
510 | while(iref<nRefs){ | |
511 | ref = mcParticle->GetTrackReference(iref); | |
512 | if(ref->LocalX() > fgkxTPC) break; | |
513 | ref=NULL; iref++; | |
514 | } | |
515 | if(ref){ | |
516 | if(ref->LocalX() > fgkxTOF){ // track skipping TRD fiducial volume | |
517 | ref = mcParticle->GetTrackReference(TMath::Max(iref-1, 0)); | |
518 | } | |
519 | } else { // track stopped in TPC | |
520 | ref = mcParticle->GetTrackReference(TMath::Max(iref-1, 0)); | |
521 | } | |
522 | ptTRD = ref->Pt();kFOUND=kTRUE; | |
523 | } else { // use reconstructed values | |
524 | if(op){ | |
525 | Double_t x(op->GetX()); | |
526 | if(x<fgkxTOF && x>fgkxTPC){ | |
527 | ptTRD=op->Pt(); | |
528 | kFOUND=kTRUE; | |
529 | } | |
530 | } | |
531 | ||
532 | if(!kFOUND && ip){ | |
533 | ptTRD=ip->Pt(); | |
534 | kFOUND=kTRUE; | |
535 | } | |
536 | } // end if(HasMC()) | |
537 | ||
538 | if(kFOUND){ | |
539 | h = (TH2I*)fHistos->At(kTRDstat); | |
540 | if(status & AliESDtrack::kTPCout) h->Fill(ptTRD, kTPCout); | |
541 | if(status & AliESDtrack::kTRDin) h->Fill(ptTRD, kTRDin); | |
542 | if(kBarrel && (status & AliESDtrack::kTRDout)) h->Fill(ptTRD, kTRDout); | |
543 | if(kBarrel && (status & AliESDtrack::kTRDpid)) h->Fill(ptTRD, kTRDpid); | |
544 | if(kBarrel && (status & AliESDtrack::kTRDrefit)) h->Fill(ptTRD, kTRDref); | |
545 | } | |
546 | Int_t idx(HasMC() ? Pdg2Idx(TMath::Abs(mcParticle->PdgCode())): 0) | |
547 | ,sgn(esdTrack->Charge()<0?0:1); | |
548 | if(kBarrel && kPhysPrim) { | |
549 | TH3 *h3 = (TH3S*)fHistos->At(kPtRes); | |
550 | Int_t offset = (status & AliESDtrack::kTRDrefit) ? 0 : 10; | |
551 | h3->Fill(pt0, 1.e2*(pt/pt0-1.), | |
552 | offset + 2*idx + sgn); | |
553 | } | |
7698e7a4 | 554 | ((TH1*)fHistos->At(kNCl))->Fill(esdTrack->GetTRDncls(), 2*idx + sgn); |
fb65de21 | 555 | if(ip){ |
556 | h = (TH2I*)fHistos->At(kTRDmom); | |
557 | Float_t pTRD(0.); | |
558 | for(Int_t ily=6; ily--;){ | |
559 | if((pTRD=esdTrack->GetTRDmomentum(ily))<0.) continue; | |
560 | h->Fill(ip->GetP()-pTRD, ily); | |
561 | } | |
562 | } | |
563 | } // end loop over tracks | |
564 | ||
565 | // fill the number of tracks histograms | |
7698e7a4 | 566 | //h = (TH1I*)fHistos->At(kNTracksAcc); |
567 | //h->Fill(nTracksAcc); | |
568 | //h = (TH1I*)fHistos->At(kNTracksTPC); | |
569 | //h->Fill(nTracksTPC); | |
570 | PostData(1, fHistos); | |
fb65de21 | 571 | } |
572 | ||
573 | //____________________________________________________________________ | |
574 | TObjArray* AliTRDcheckESD::Histos() | |
575 | { | |
576 | // Retrieve histograms array if already build or build it | |
577 | ||
578 | if(fHistos) return fHistos; | |
579 | ||
7698e7a4 | 580 | fHistos = new TObjArray(kNhistos+1); |
246fe7f7 | 581 | fHistos->SetOwner(kTRUE); |
fb65de21 | 582 | |
583 | TH1 *h = NULL; | |
584 | ||
585 | // clusters per track | |
586 | const Int_t kNpt(30); | |
587 | Float_t pt(0.2); | |
588 | Float_t binsPt[kNpt+1]; | |
589 | for(Int_t i=0;i<kNpt+1; i++,pt+=(TMath::Exp(i*i*.001)-1.)) binsPt[i]=pt; | |
647cf3fa | 590 | if(!(h = (TH2I*)gROOT->FindObject("hNCl"))){ |
591 | h = new TH2I("hNCl", "Clusters per TRD track;N_{cl}^{TRD};SPECIES;entries", 60, 0., 180., 10, -0.5, 9.5); | |
fb65de21 | 592 | TAxis *ay(h->GetYaxis()); |
593 | ay->SetLabelOffset(0.015); | |
594 | for(Int_t i(0); i<AliPID::kSPECIES; i++){ | |
595 | ay->SetBinLabel(2*i+1, Form("%s^{-}", AliPID::ParticleLatexName(i))); | |
596 | ay->SetBinLabel(2*i+2, Form("%s^{+}", AliPID::ParticleLatexName(i))); | |
597 | } | |
598 | } else h->Reset(); | |
599 | fHistos->AddAt(h, kNCl); fNRefFigures++; | |
600 | ||
601 | // status bits histogram | |
602 | const Int_t kNbits(5); | |
603 | Float_t bits(.5); | |
604 | Float_t binsBits[kNbits+1]; | |
605 | for(Int_t i=0; i<kNbits+1; i++,bits+=1.) binsBits[i]=bits; | |
606 | if(!(h = (TH2I*)gROOT->FindObject("hTRDstat"))){ | |
607 | h = new TH2I("hTRDstat", "TRD status bits;p_{t} @ TRD [GeV/c];status;entries", kNpt, binsPt, kNbits, binsBits); | |
608 | TAxis *ay(h->GetYaxis()); | |
609 | ay->SetBinLabel(1, "kTPCout"); | |
610 | ay->SetBinLabel(2, "kTRDin"); | |
611 | ay->SetBinLabel(3, "kTRDout"); | |
612 | ay->SetBinLabel(4, "kTRDpid"); | |
613 | ay->SetBinLabel(5, "kTRDrefit"); | |
614 | } else h->Reset(); | |
615 | fHistos->AddAt(h, kTRDstat); | |
616 | ||
617 | // energy loss | |
618 | if(!(h = (TH2I*)gROOT->FindObject("hTRDmom"))){ | |
619 | h = new TH2I("hTRDmom", "TRD energy loss;p_{inner} - p_{ly} [GeV/c];ly;entries", 100, -1., 2., 6, -0.5, 5.5); | |
620 | } else h->Reset(); | |
621 | fHistos->AddAt(h, kTRDmom); | |
622 | //if(!HasMC()) return fHistos; | |
623 | ||
624 | // pt resolution | |
625 | const Int_t kNdpt(100), kNspec(4*AliPID::kSPECIES); | |
626 | Float_t dpt(-3.), spec(-0.5); | |
627 | Float_t binsDPt[kNdpt+1], binsSpec[kNspec+1]; | |
628 | for(Int_t i=0; i<kNdpt+1; i++,dpt+=6.e-2) binsDPt[i]=dpt; | |
629 | for(Int_t i=0; i<kNspec+1; i++,spec+=1.) binsSpec[i]=spec; | |
630 | if(!(h = (TH3S*)gROOT->FindObject("hPtRes"))){ | |
631 | h = new TH3S("hPtRes", "P_{t} resolution @ DCA;p_{t}^{MC} [GeV/c];#Delta p_{t}/p_{t}^{MC} [%];SPECIES", kNpt, binsPt, kNdpt, binsDPt, kNspec, binsSpec); | |
632 | TAxis *az(h->GetZaxis()); | |
633 | az->SetLabelOffset(0.015); | |
634 | for(Int_t i(0); i<AliPID::kSPECIES; i++){ | |
635 | az->SetBinLabel(2*i+1, Form("%s^{-}", AliPID::ParticleLatexName(i))); | |
636 | az->SetBinLabel(2*i+2, Form("%s^{+}", AliPID::ParticleLatexName(i))); | |
637 | az->SetBinLabel(10+2*i+1, Form("%s^{-}", AliPID::ParticleLatexName(i))); | |
638 | az->SetBinLabel(10+2*i+2, Form("%s^{+}", AliPID::ParticleLatexName(i))); | |
639 | } | |
640 | } else h->Reset(); | |
641 | fHistos->AddAt(h, kPtRes); | |
642 | ||
643 | // TPC event vertex distribution | |
644 | if(!(h = (TH1F*)gROOT->FindObject("hTPCVertex"))){ | |
645 | h = new TH1F("hTPCVertex", "Event vertex Z coord. from TPC tracks", 100, -25., 25.); | |
646 | } else h->Reset(); | |
647 | fHistos->AddAt(h, kTPCVertex); | |
648 | ||
649 | // Event vertex | |
650 | if(!(h = (TH1F*)gROOT->FindObject("hEventVertex"))){ | |
651 | h = new TH1F("hEventVertex", "Event vertex Z coord.", 100, -25., 25.); | |
652 | } else h->Reset(); | |
653 | fHistos->AddAt(h, kEventVertex); | |
654 | ||
655 | // Number of all tracks | |
656 | if(!(h = (TH1I*)gROOT->FindObject("hNTracksAll"))){ | |
657 | h = new TH1I("hNTracksAll", "Number of tracks per event, event vertex cuts", 5000, 0, 5000); | |
658 | } else h->Reset(); | |
659 | fHistos->AddAt(h, kNTracksAll); | |
660 | ||
661 | // Number of tracks in acceptance and DCA cut | |
662 | if(!(h = (TH1I*)gROOT->FindObject("hNTracksAcc"))){ | |
663 | h = new TH1I("hNTracksAcc", Form("Number of tracks per event, |#eta|<%.1f, |DCAxy|<%.1f, |DCAz|<%.1f", | |
664 | fgkEta, fgkTrkDCAxy, fgkTrkDCAz), 5000, 0, 5000); | |
665 | } else h->Reset(); | |
666 | fHistos->AddAt(h, kNTracksAcc); | |
667 | ||
668 | // Number of tracks in TPC (Ncls>10) | |
669 | if(!(h = (TH1I*)gROOT->FindObject("hNTracksTPC"))){ | |
670 | h = new TH1I("hNTracksTPC", Form("Number of tracks per event, |#eta|<%.1f, pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
671 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 5000, 0, 5000); | |
672 | } else h->Reset(); | |
673 | fHistos->AddAt(h, kNTracksTPC); | |
674 | ||
675 | // Distribution of DCA-xy | |
676 | if(!(h = (TH1F*)gROOT->FindObject("hDCAxy"))){ | |
677 | h = new TH1F("hDCAxy", "Distribution of transverse DCA", 100, -100., 100.); | |
678 | } else h->Reset(); | |
679 | fHistos->AddAt(h, kDCAxy); | |
680 | ||
681 | // Distribution of DCA-z | |
682 | if(!(h = (TH1F*)gROOT->FindObject("hDCAz"))){ | |
683 | h = new TH1F("hDCAz", "Distribution of longitudinal DCA", 100, -100., 100.); | |
684 | } else h->Reset(); | |
685 | fHistos->AddAt(h, kDCAz); | |
686 | ||
7698e7a4 | 687 | Double_t binPtLimits[33] = {0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, |
fb65de21 | 688 | 1.0, 1.1, 1.2, 1.3, 1.4, |
689 | 1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, | |
690 | 3.4, 3.8, 4.2, 4.6, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0}; | |
691 | // Pt distributions | |
692 | if(!(h = (TH1F*)gROOT->FindObject("hPt1"))){ | |
693 | h = new TH1F("hPt1", Form("dN/dpt, |#eta|<%.1f and pt>%.1f", fgkEta, fgkPt), 32, binPtLimits); | |
694 | } else h->Reset(); | |
695 | fHistos->AddAt(h, kPt1); | |
696 | ||
697 | if(!(h = (TH1F*)gROOT->FindObject("hPt2"))){ | |
698 | h = new TH1F("hPt2", Form("dN/dpt, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f", | |
699 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 32, binPtLimits); | |
700 | } else h->Reset(); | |
701 | fHistos->AddAt(h, kPt2); | |
702 | ||
703 | if(!(h = (TH1F*)gROOT->FindObject("hPt3pos"))){ | |
704 | h = new TH1F("hPt3pos", Form("dN/dpt (positives), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
705 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 32, binPtLimits); | |
706 | } else h->Reset(); | |
707 | fHistos->AddAt(h, kPt3pos); | |
708 | ||
709 | if(!(h = (TH1F*)gROOT->FindObject("hPt3neg"))){ | |
710 | h = new TH1F("hPt3neg", Form("dN/dpt (negatives), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
711 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 32, binPtLimits); | |
712 | } else h->Reset(); | |
713 | fHistos->AddAt(h, kPt3neg); | |
714 | ||
715 | if(!(h = (TH1F*)gROOT->FindObject("hPt4pos"))){ | |
716 | h = new TH1F("hPt4pos", Form("dN/dpt (positives), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq 1", | |
717 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 32, binPtLimits); | |
718 | } else h->Reset(); | |
719 | fHistos->AddAt(h, kPt4pos); | |
720 | ||
721 | if(!(h = (TH1F*)gROOT->FindObject("hPt4neg"))){ | |
722 | h = new TH1F("hPt4pos", Form("dN/dpt (negatives), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq 1", | |
723 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 32, binPtLimits); | |
724 | } else h->Reset(); | |
725 | fHistos->AddAt(h, kPt4neg); | |
726 | ||
727 | // theta distribution of TRD tracks | |
728 | if(!(h = (TH1F*)gROOT->FindObject("hTheta"))){ | |
729 | h = new TH1F("hTheta", Form("dN/d#theta, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq 1", | |
730 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 220,.5,2.7); | |
731 | } else h->Reset(); | |
732 | fHistos->AddAt(h, kTheta); | |
733 | ||
734 | // phi distribution of TRD tracks | |
735 | if(!(h = (TH1F*)gROOT->FindObject("hPhi"))){ | |
736 | h = new TH1F("hPhi", Form("dN/d#varphi, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq 1", | |
737 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 157,0,6.28); | |
738 | } else h->Reset(); | |
739 | fHistos->AddAt(h, kPhi); | |
740 | ||
741 | // TPC cluster distribution | |
742 | if(!(h = (TH1F*)gROOT->FindObject("hNTPCCl"))){ | |
743 | h = new TH1I("hNTPCCl", Form("Number of TPC clusters/track, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f", | |
744 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 160, 0, 160); | |
745 | } else h->Reset(); | |
746 | fHistos->AddAt(h, kNTPCCl); | |
747 | ||
748 | if(!(h = (TH1I*)gROOT->FindObject("hNTPCCl2"))){ | |
749 | h = new TH1F("hNTPCCl2", Form("Number of TPC clusters/track, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, pt>1.0 GeV/c", | |
750 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 160, 0, 160); | |
751 | } else h->Reset(); | |
752 | fHistos->AddAt(h, kNTPCCl2); | |
753 | ||
754 | // dE/dx vs P for TPC reference tracks | |
755 | if(!(h = (TH2F*)gROOT->FindObject("hTPCDedx"))){ | |
756 | h = new TH2F("hTPCDedx", Form("TPC dE/dx vs P, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
2bf6d80c | 757 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, 0.1,10.1, 150, 0, 150.); |
fb65de21 | 758 | } else h->Reset(); |
759 | fHistos->AddAt(h, kTPCDedx); | |
760 | ||
761 | // eta,phi distribution of TPC reference tracks | |
762 | if(!(h = (TH2F*)gROOT->FindObject("hEtaPhi"))){ | |
763 | h = new TH2F("hEtaPhi", Form("TPC (#eta,#varphi), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
764 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 50, -1, 1, 157, 0, 6.28); | |
765 | } else h->Reset(); | |
766 | fHistos->AddAt(h, kEtaPhi); | |
767 | ||
768 | // Nclusters vs eta distribution for TPC tracks | |
769 | if(!(h = (TH2F*)gROOT->FindObject("hEtaNclsTPC"))){ | |
770 | h = new TH2F("hEtaNclsTPC", Form("TPC Nclusters vs. #eta, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f", | |
771 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 50, -1, 1, 160, 0, 160.); | |
772 | } else h->Reset(); | |
773 | fHistos->AddAt(h, kEtaNclsTPC); | |
774 | ||
775 | // Nclusters vs phi distribution for TPC reference tracks | |
776 | if(!(h = (TH2F*)gROOT->FindObject("hPhiNclsTPC"))){ | |
777 | h = new TH2F("hPhiNclsTPC", Form("TPC Nclusters vs. #varphi, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f", | |
778 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 157, 0, 6.28, 160, 0, 160.); | |
779 | } else h->Reset(); | |
780 | fHistos->AddAt(h, kPhiNclsTPC); | |
2bf6d80c | 781 | |
782 | // SPD multiplicity distribution | |
783 | if(!(h = (TH1F*)gROOT->FindObject("hSPDMult"))){ | |
784 | h = new TH1F("hSPDMult", "SPD multiplicity", 10000, -0.5, 9999.5); | |
785 | } else h->Reset(); | |
786 | fHistos->AddAt(h, kSPDMult); | |
787 | ||
fb65de21 | 788 | // Ntracklets/track vs P for TRD reference tracks |
789 | Double_t binsP[19] = {0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.7, 2.0, | |
790 | 2.5, 3.0, 3.5, 4.0, 5.0, 6.0, 7.0, 9.0, 12.0}; | |
2bf6d80c | 791 | for(Int_t iCent=0; iCent<=5; ++iCent) { |
792 | if(!(h = (TH2F*)gROOT->FindObject(Form("hNTrackletsTRD_cent%d",iCent+1)))){ | |
793 | h = new TH2F(Form("hNTrackletsTRD_cent%d",iCent+1), Form("TRD Ntracklets/track vs. P, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
794 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 18, binsP, 7, -0.5, 6.5); | |
795 | } else h->Reset(); | |
796 | fHistos->AddAt(h, kNTrackletsTRD+iCent); | |
797 | } | |
fb65de21 | 798 | |
799 | // Nclusters/track vs P for TRD reference tracks | |
2bf6d80c | 800 | for(Int_t iCent=0; iCent<=5; ++iCent) { |
801 | if(!(h = (TH2F*)gROOT->FindObject(Form("hNClsTrackTRD_cent%d",iCent+1)))){ | |
802 | h = new TH2F(Form("hNClsTrackTRD_cent%d",iCent+1), Form("TRD Nclusters/track vs. P, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
803 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 18, binsP, 300, 0., 300.); | |
804 | } else h->Reset(); | |
805 | fHistos->AddAt(h, kNClsTrackTRD+iCent); | |
806 | } | |
807 | ||
fb65de21 | 808 | // <PH> vs slice number for TRD reference tracklets |
2bf6d80c | 809 | for(Int_t iCent=0; iCent<=5; ++iCent) { |
810 | if(!(h = (TH2F*)gROOT->FindObject(Form("hPHSlice_cent%d",iCent+1)))){ | |
811 | h = new TH2F(Form("hPHSlice_cent%d",iCent+1), Form("<PH> vs sliceNo, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
812 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 8, -0.5, 7.5, 200, 0., 2000.); | |
813 | } else h->Reset(); | |
814 | fHistos->AddAt(h, kPHSlice+iCent); | |
815 | } | |
fb65de21 | 816 | |
817 | // <PH> vs slice number for TRD reference tracklets, from TPC pions | |
2bf6d80c | 818 | for(Int_t iCent=0; iCent<=5; ++iCent) { |
819 | if(!(h = (TH2F*)gROOT->FindObject(Form("hPHSliceTPCpions_cent%d",iCent+1)))){ | |
820 | h = new TH2F(Form("hPHSliceTPCpions_cent%d",iCent+1), Form("<PH> vs sliceNo, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, TPC pions", | |
821 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 8, -0.5, 7.5, 100, 0., 2000.); | |
822 | } else h->Reset(); | |
823 | fHistos->AddAt(h, kPHSliceTPCpions+iCent); | |
824 | } | |
fb65de21 | 825 | |
826 | // TPC dE/dx vs P for TRD reference tracks, pions | |
2bf6d80c | 827 | for(Int_t iCent=0; iCent<=5; ++iCent) { |
828 | if(!(h = (TH2F*)gROOT->FindObject(Form("hTPCdedxPions_cent%d",iCent+1)))){ | |
829 | h = new TH2F(Form("hTPCdedxPions_cent%d",iCent+1), Form("TPC dE/dx vs P, TPC pions, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
830 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, 0.1,10.1, 100, 0,100.); | |
831 | } else h->Reset(); | |
832 | fHistos->AddAt(h, kTPCdedxPions+iCent); | |
833 | } | |
fb65de21 | 834 | |
835 | // <PH> vs slice number for TRD reference tracklets, from TPC electrons | |
2bf6d80c | 836 | for(Int_t iCent=0; iCent<=5; ++iCent) { |
837 | if(!(h = (TH2F*)gROOT->FindObject(Form("hPHSliceTPCelectrons_cent%d",iCent+1)))){ | |
838 | h = new TH2F(Form("hPHSliceTPCelectrons_cent%d",iCent+1), Form("<PH> vs sliceNo, centrality %d,|#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, TPC electrons", | |
839 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 8, -0.5, 7.5, 100, 0., 2000.); | |
840 | } else h->Reset(); | |
841 | fHistos->AddAt(h, kPHSliceTPCelectrons+iCent); | |
842 | } | |
fb65de21 | 843 | |
844 | // TPC dE/dx vs P for TRD reference tracks, electrons | |
2bf6d80c | 845 | for(Int_t iCent=0; iCent<=5; ++iCent) { |
846 | if(!(h = (TH2F*)gROOT->FindObject(Form("hTPCdedxElectrons_cent%d",iCent+1)))){ | |
847 | h = new TH2F(Form("hTPCdedxElectrons_cent%d",iCent+1), Form("TPC dE/dx vs P, TPC electrons, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
848 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, 0.1,10.1, 100, 0,100.); | |
849 | } else h->Reset(); | |
850 | fHistos->AddAt(h, kTPCdedxElectrons+iCent); | |
851 | } | |
852 | ||
fb65de21 | 853 | // Qtot vs P for TRD reference tracklets |
2bf6d80c | 854 | for(Int_t iCent=0; iCent<=5; ++iCent) { |
855 | if(!(h = (TH2F*)gROOT->FindObject(Form("hQtotP_cent%d",iCent+1)))){ | |
856 | h = new TH2F(Form("hQtotP_cent%d",iCent+1), Form("Qtot(from slices) vs P, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
857 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 18, binsP, 400, 0., 20); | |
858 | } else h->Reset(); | |
859 | fHistos->AddAt(h, kQtotP+iCent); | |
860 | } | |
fb65de21 | 861 | |
862 | // (X,Y,momentum) distribution after AliESDtrack::PropagateTo(r=300.) | |
863 | if(!(h = (TH3F*)gROOT->FindObject("hPropagXYvsP"))){ | |
864 | h = new TH3F("hPropagXYvsP", Form("(x,y) vs P after AliESDtrack::PropagateTo(r=300.), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
865 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100,-500,500, 100,-500,500, 10, 0.,10.); | |
866 | } else h->Reset(); | |
867 | fHistos->AddAt(h, kPropagXYvsP); | |
868 | ||
869 | // (R,Z,momentum) distribution after AliESDtrack::PropagateTo(r=300.) | |
870 | if(!(h = (TH3F*)gROOT->FindObject("hPropagRZvsP"))){ | |
871 | h = new TH3F("hPropagRZvsP", Form("(r,z) vs P after AliESDtrack::PropagateTo(r=300.), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
872 | fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100,-350., 350., 100,0.,500., 10, 0.,10.); | |
873 | } else h->Reset(); | |
874 | fHistos->AddAt(h, kPropagRZvsP); | |
875 | ||
7698e7a4 | 876 | Double_t etaBinLimits[101]; |
fb65de21 | 877 | for(Int_t i=0; i<101; i++) etaBinLimits[i] = -1.0 + i*2.0/100.; |
7698e7a4 | 878 | Double_t phiBinLimits[151]; |
fb65de21 | 879 | for(Int_t i=0; i<151; i++) phiBinLimits[i] = -1.1*TMath::Pi() + i*2.2*TMath::Pi()/150.; |
880 | // (eta,detector phi,P) distribution of reference TPC positive tracks | |
2bf6d80c | 881 | for(Int_t iCent=0; iCent<=5; ++iCent) { |
882 | if(!(h = (TH3F*)gROOT->FindObject(Form("hTPCRefTracksPos_cent%d",iCent+1)))){ | |
883 | h = new TH3F(Form("hTPCRefTracksPos_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TPC positive reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
884 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits); | |
885 | } else h->Reset(); | |
886 | fHistos->AddAt(h, kTPCRefTracksPos+iCent); | |
887 | } | |
fb65de21 | 888 | |
889 | // (eta,detector phi,P) distribution of reference TPC negative tracks | |
2bf6d80c | 890 | for(Int_t iCent=0; iCent<=5; ++iCent) { |
891 | if(!(h = (TH3F*)gROOT->FindObject(Form("hTPCRefTracksNeg_cent%d",iCent+1)))){ | |
892 | h = new TH3F(Form("hTPCRefTracksNeg_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TPC negative reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d", | |
893 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits); | |
894 | } else h->Reset(); | |
895 | fHistos->AddAt(h, kTPCRefTracksNeg+iCent); | |
896 | } | |
fb65de21 | 897 | |
898 | // (eta,detector phi,P) distribution of reference TRD positive tracks | |
2bf6d80c | 899 | for(Int_t iCent=0; iCent<=5; ++iCent) { |
900 | if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksPos_cent%d",iCent+1)))){ | |
901 | h = new TH3F(Form("hTRDRefTracksPos_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD positive reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1", | |
902 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits); | |
903 | } else h->Reset(); | |
904 | fHistos->AddAt(h, kTRDRefTracksPos+iCent); | |
905 | } | |
fb65de21 | 906 | |
907 | // (eta,detector phi,P) distribution of reference TRD negative tracks | |
2bf6d80c | 908 | for(Int_t iCent=0; iCent<=5; ++iCent) { |
909 | if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksNeg_cent%d",iCent+1)))){ | |
910 | h = new TH3F(Form("hTRDRefTracksNeg_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD negative reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1", | |
911 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits); | |
912 | } else h->Reset(); | |
913 | fHistos->AddAt(h, kTRDRefTracksNeg+iCent); | |
914 | } | |
915 | ||
916 | // (eta,detector phi,P) distribution of reference TRD positive tracks with 4 tracklets | |
917 | for(Int_t iCent=0; iCent<=5; ++iCent) { | |
918 | if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksPos4_cent%d",iCent+1)))){ | |
919 | h = new TH3F(Form("hTRDRefTracksPos4_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD positive reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1", | |
920 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits); | |
921 | } else h->Reset(); | |
922 | fHistos->AddAt(h, kTRDRefTracksPos4+iCent); | |
923 | } | |
924 | ||
925 | // (eta,detector phi,P) distribution of reference TRD positive tracks with 5 tracklets | |
926 | for(Int_t iCent=0; iCent<=5; ++iCent) { | |
927 | if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksPos5_cent%d",iCent+1)))){ | |
928 | h = new TH3F(Form("hTRDRefTracksPos5_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD positive reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1", | |
929 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits); | |
930 | } else h->Reset(); | |
931 | fHistos->AddAt(h, kTRDRefTracksPos5+iCent); | |
932 | } | |
933 | ||
934 | // (eta,detector phi,P) distribution of reference TRD positive tracks with 6 tracklets | |
935 | for(Int_t iCent=0; iCent<=5; ++iCent) { | |
936 | if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksPos6_cent%d",iCent+1)))){ | |
937 | h = new TH3F(Form("hTRDRefTracksPos6_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD positive reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1", | |
938 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits); | |
939 | } else h->Reset(); | |
940 | fHistos->AddAt(h, kTRDRefTracksPos6+iCent); | |
941 | } | |
fb65de21 | 942 | |
2bf6d80c | 943 | // (eta,detector phi,P) distribution of reference TRD negative tracks with 4 tracklets |
944 | for(Int_t iCent=0; iCent<=5; ++iCent) { | |
945 | if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksNeg4_cent%d",iCent+1)))){ | |
946 | h = new TH3F(Form("hTRDRefTracksNeg4_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD negative reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1", | |
947 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits); | |
948 | } else h->Reset(); | |
949 | fHistos->AddAt(h, kTRDRefTracksNeg4+iCent); | |
950 | } | |
951 | ||
952 | // (eta,detector phi,P) distribution of reference TRD negative tracks with 5 tracklets | |
953 | for(Int_t iCent=0; iCent<=5; ++iCent) { | |
954 | if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksNeg5_cent%d",iCent+1)))){ | |
955 | h = new TH3F(Form("hTRDRefTracksNeg5_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD negative reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1", | |
956 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits); | |
957 | } else h->Reset(); | |
958 | fHistos->AddAt(h, kTRDRefTracksNeg5+iCent); | |
959 | } | |
960 | ||
961 | // (eta,detector phi,P) distribution of reference TRD negative tracks with 6 tracklets | |
962 | for(Int_t iCent=0; iCent<=5; ++iCent) { | |
963 | if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksNeg6_cent%d",iCent+1)))){ | |
964 | h = new TH3F(Form("hTRDRefTracksNeg6_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD negative reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1", | |
965 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits); | |
966 | } else h->Reset(); | |
967 | fHistos->AddAt(h, kTRDRefTracksNeg6+iCent); | |
968 | } | |
969 | ||
970 | ||
fb65de21 | 971 | // (eta,detector phi) profile of average number of TRD tracklets/track |
2bf6d80c | 972 | for(Int_t iCent=0; iCent<=5; ++iCent) { |
973 | if(!(h = (TProfile2D*)gROOT->FindObject(Form("hTRDEtaPhiAvNtrkl_cent%d",iCent+1)))){ | |
974 | h = new TProfile2D(Form("hTRDEtaPhiAvNtrkl_cent%d",iCent+1), Form("<Ntracklets/track> vs (#eta,detector #varphi) for TRD reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1", | |
975 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, -1.0, 1.0, 150, -1.1*TMath::Pi(), 1.1*TMath::Pi()); | |
976 | } else h->Reset(); | |
977 | fHistos->AddAt(h, kTRDEtaPhiAvNtrkl+iCent); | |
978 | } | |
fb65de21 | 979 | |
980 | // (eta,delta phi) profile of average number of TRD tracklets/track | |
2bf6d80c | 981 | for(Int_t iCent=0; iCent<=5; ++iCent) { |
982 | if(!(h = (TProfile2D*)gROOT->FindObject(Form("hTRDEtaDeltaPhiAvNtrkl_cent%d",iCent+1)))){ | |
983 | h = new TProfile2D(Form("hTRDEtaDeltaPhiAvNtrkl_cent%d",iCent+1), Form("<Ntracklets/track> vs (#eta, #Delta#varphi) for TRD reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1", | |
984 | iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, -1.0, 1.0, 50, -0.4*TMath::Pi(), 0.4*TMath::Pi()); | |
fb65de21 | 985 | } else h->Reset(); |
2bf6d80c | 986 | fHistos->AddAt(h, kTRDEtaDeltaPhiAvNtrkl+iCent); |
987 | } | |
988 | ||
989 | // (eta, detector phi) profile of average tracklet Qtot from slices | |
990 | for(Int_t iCent=0; iCent<=5; ++iCent) { | |
991 | for(Int_t iLayer=0;iLayer<6;iLayer++) { | |
992 | if(!(h = (TProfile2D*)gROOT->FindObject(Form("hTRDEtaPhiAvQtot_Layer%d_cent%d",iLayer,iCent+1)))) { | |
993 | h = new TProfile2D(Form("hTRDEtaPhiAvQtot_Layer%d_cent%d",iLayer,iCent+1), | |
994 | Form("<Q_{tot}> vs (#eta, detector #varphi) for TRD reference tracks (layer %d), centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1", | |
995 | iLayer, iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, -1.0, 1.0, 150, -1.1*TMath::Pi(), 1.1*TMath::Pi()); | |
996 | } else h->Reset(); | |
997 | fHistos->AddAt(h, kTRDEtaPhiAvQtot+iCent*6+iLayer); | |
998 | } | |
fb65de21 | 999 | } |
1000 | ||
7698e7a4 | 1001 | // create a CF container and add it to the list of histograms |
1002 | Int_t nbinsCf[kNTrdCfVariables]; | |
1003 | for(Int_t i=0;i<kNTrdCfVariables;++i) nbinsCf[i]=0; | |
1004 | nbinsCf[kEventVtxZ] = 12; | |
1005 | nbinsCf[kEventMult] = 5; | |
1006 | nbinsCf[kEventBC] = 3500; | |
1007 | nbinsCf[kTrackTOFdeltaBC] = 2001; | |
33d501fa | 1008 | nbinsCf[kTrackTOFBC] = 201; |
1009 | nbinsCf[kTrackDCAxy] = 26; | |
1010 | nbinsCf[kTrackDCAz] = 101; | |
7698e7a4 | 1011 | nbinsCf[kTrackCharge] = 2; |
1012 | nbinsCf[kTrackPhi] = 150; | |
1013 | nbinsCf[kTrackEta] = 100; | |
1014 | nbinsCf[kTrackPt] = 32; | |
1015 | nbinsCf[kTrackP] = 18; | |
1016 | nbinsCf[kTrackTrdTracklets] = 7; | |
1017 | nbinsCf[kTrackTrdClusters] = 200; | |
1018 | for(Int_t i=0;i<6;++i) nbinsCf[kTrackQtot+i] = 100; | |
1019 | Double_t evVtxLims[2] = {-12.,+12.}; | |
1020 | Double_t evMultLims[6] = {0.0, 700., 1400., 2100., 2800., 3500.}; | |
1021 | Double_t evBCLims[2] = {-0.5, +3499.5}; | |
1022 | Double_t trkTOFdeltaBClims[2] = {-1000.5, 1000.5}; | |
33d501fa | 1023 | Double_t trkTOFBClims[2] = {-100.5, 100.5}; |
1024 | Double_t trkDCAxyLims[27] = {-50.0, -40.0, -30.0, -25.0, -20.0, | |
1025 | -15.0, -10.0, -8.0, -6.0, -4.0, | |
1026 | -3.0, -2.0, -1.0, 0.0, +1.0, | |
1027 | +2.0, +3.0, +4.0, +6.0, +8.0, | |
1028 | +10.0, +15.0, +20.0, +25.0, +30.0, | |
1029 | +40.0, +50.0}; | |
1030 | Double_t trkDCAzLims[2] = {-50.5, +50.5}; | |
7698e7a4 | 1031 | Double_t trkChargeLims[2] = {-1.5, +1.5}; |
1032 | Double_t trkPhiLims[2] = {-1.1*TMath::Pi(), +1.1*TMath::Pi()}; | |
1033 | Double_t trkEtaLims[2] = {-1.0, +1.0}; | |
1034 | Double_t trkPtLims[33] = {0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, | |
1035 | 1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4, | |
1036 | 2.6, 2.8, 3.0, 3.4, 3.8, 4.2, 4.6, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0}; | |
1037 | Double_t trkPLims[19] = {0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.7, 2.0, | |
1038 | 2.5, 3.0, 3.5, 4.0, 5.0, 6.0, 7.0, 9.0, 12.0}; | |
1039 | Double_t trkTrdNLims[2] = {-0.5, 6.5}; | |
1040 | Double_t trkTrdNclsLims[2] = {-0.5, 199.5}; | |
1041 | Double_t trkQtotLims[2] = {0.0, 20.}; | |
1042 | fCfContainer = new AliCFContainer("TrdCfContainer", "TRD ESD CF container", 3, kNTrdCfVariables, nbinsCf); | |
1043 | fCfContainer->SetBinLimits(kEventVtxZ, evVtxLims[0], evVtxLims[1]); | |
1044 | fCfContainer->SetBinLimits(kEventMult, evMultLims); | |
1045 | fCfContainer->SetBinLimits(kEventBC, evBCLims[0], evBCLims[1]); | |
1046 | fCfContainer->SetBinLimits(kTrackTOFdeltaBC, trkTOFdeltaBClims[0], trkTOFdeltaBClims[1]); | |
33d501fa | 1047 | fCfContainer->SetBinLimits(kTrackTOFBC, trkTOFBClims[0], trkTOFBClims[1]); |
1048 | fCfContainer->SetBinLimits(kTrackDCAxy, trkDCAxyLims); | |
1049 | fCfContainer->SetBinLimits(kTrackDCAz, trkDCAzLims[0], trkDCAzLims[1]); | |
7698e7a4 | 1050 | fCfContainer->SetBinLimits(kTrackCharge, trkChargeLims[0], trkChargeLims[1]); |
1051 | fCfContainer->SetBinLimits(kTrackPhi, trkPhiLims[0], trkPhiLims[1]); | |
1052 | fCfContainer->SetBinLimits(kTrackEta, trkEtaLims[0], trkEtaLims[1]); | |
1053 | fCfContainer->SetBinLimits(kTrackPt, trkPtLims); | |
1054 | fCfContainer->SetBinLimits(kTrackP, trkPLims); | |
1055 | fCfContainer->SetBinLimits(kTrackTrdTracklets, trkTrdNLims[0], trkTrdNLims[1]); | |
1056 | fCfContainer->SetBinLimits(kTrackTrdClusters, trkTrdNclsLims[0], trkTrdNclsLims[1]); | |
1057 | for(Int_t i=0; i<6; ++i) fCfContainer->SetBinLimits(kTrackQtot+i, trkQtotLims[0], trkQtotLims[1]); | |
1058 | fCfContainer->SetVarTitle(kEventVtxZ, "vtxZ"); | |
1059 | fCfContainer->SetVarTitle(kEventMult, "multiplicity"); | |
1060 | fCfContainer->SetVarTitle(kEventBC, "BC"); | |
1061 | fCfContainer->SetVarTitle(kTrackTOFdeltaBC, "TOFdeltaBC"); | |
33d501fa | 1062 | fCfContainer->SetVarTitle(kTrackTOFBC, "TOFBC"); |
1063 | fCfContainer->SetVarTitle(kTrackDCAxy, "DCAxy"); | |
1064 | fCfContainer->SetVarTitle(kTrackDCAz, "DCAz"); | |
7698e7a4 | 1065 | fCfContainer->SetVarTitle(kTrackCharge, "charge"); |
1066 | fCfContainer->SetVarTitle(kTrackPhi, "phi"); | |
1067 | fCfContainer->SetVarTitle(kTrackEta, "eta"); | |
1068 | fCfContainer->SetVarTitle(kTrackPt, "pt"); | |
1069 | fCfContainer->SetVarTitle(kTrackP, "P"); | |
1070 | fCfContainer->SetVarTitle(kTrackTrdTracklets, "tracklets"); | |
1071 | fCfContainer->SetVarTitle(kTrackTrdClusters, "clusters"); | |
1072 | for(Int_t i=0; i<6; ++i) fCfContainer->SetVarTitle(kTrackQtot+i, Form("Qtot%d",i)); | |
1073 | ||
1074 | fCfContainer->SetStepTitle(0, "TPC reference"); | |
1075 | fCfContainer->SetStepTitle(1, "TRD"); | |
1076 | fCfContainer->SetStepTitle(2, "TOF"); | |
1077 | ||
647cf3fa | 1078 | // fHistos->AddAt(fCfContainer, kNhistos); |
1079 | fHistos->AddAt(fCfContainer, 0); | |
7698e7a4 | 1080 | |
fb65de21 | 1081 | return fHistos; |
1082 | } | |
1083 | ||
1084 | //____________________________________________________________________ | |
1085 | Bool_t AliTRDcheckESD::Load(const Char_t *file, const Char_t *dir, const Char_t *name) | |
1086 | { | |
1087 | // Load data from performance file | |
1088 | ||
1089 | if(!TFile::Open(file)){ | |
1090 | AliWarning(Form("Couldn't open file %s.", file)); | |
1091 | return kFALSE; | |
1092 | } | |
1093 | if(dir){ | |
1094 | if(!gFile->cd(dir)){ | |
1095 | AliWarning(Form("Couldn't cd to %s in %s.", dir, file)); | |
1096 | return kFALSE; | |
1097 | } | |
1098 | } | |
1099 | TObjArray *o(NULL); | |
1100 | const Char_t *tn=(name ? name : GetName()); | |
1101 | if(!(o = (TObjArray*)gDirectory->Get(tn))){ | |
1102 | AliWarning(Form("Missing histogram container %s.", tn)); | |
1103 | return kFALSE; | |
1104 | } | |
1105 | fHistos = (TObjArray*)o->Clone(GetName()); | |
647cf3fa | 1106 | fCfContainer = (AliCFContainer*)fHistos->At(0); |
fb65de21 | 1107 | gFile->Close(); |
1108 | return kTRUE; | |
1109 | } | |
1110 | ||
1111 | //_______________________________________________________ | |
1112 | Bool_t AliTRDcheckESD::PutTrendValue(const Char_t *name, Double_t val) | |
1113 | { | |
1114 | // Dump trending value to default file | |
1115 | ||
1116 | if(!fgFile){ | |
1117 | fgFile = fopen("TRD.Performance.txt", "at"); | |
1118 | } | |
1119 | fprintf(fgFile, "%s_%s %f\n", GetName(), name, val); | |
1120 | return kTRUE; | |
1121 | } | |
1122 | ||
1123 | //____________________________________________________________________ | |
1124 | void AliTRDcheckESD::Terminate(Option_t *) | |
1125 | { | |
2bf6d80c | 1126 | // Steer post-processing |
fb65de21 | 1127 | if(!fHistos){ |
1128 | fHistos = dynamic_cast<TObjArray *>(GetOutputData(1)); | |
1129 | if(!fHistos){ | |
1130 | AliError("Histogram container not found in output"); | |
1131 | return; | |
1132 | } | |
1133 | } | |
1134 | ||
2bf6d80c | 1135 | // fNRefFigures = 15; |
1136 | // return; | |
1137 | ||
fb65de21 | 1138 | const Char_t *name[kNrefs] = { |
1139 | "Ncl", "Eff", "Eloss", "PtResDCA" | |
1140 | }; | |
2bf6d80c | 1141 | |
fb65de21 | 1142 | TObjArray *arr(NULL); TGraph *g(NULL); |
1143 | if(!fResults){ | |
1144 | fResults = new TObjArray(kNrefs); | |
1145 | fResults->SetOwner(); | |
1146 | fResults->SetName("results"); | |
1147 | for(Int_t iref(0); iref<kNrefs; iref++){ | |
1148 | fResults->AddAt(arr = new TObjArray(fgkNgraph[iref]), iref); | |
1149 | arr->SetName(name[iref]); arr->SetOwner(); | |
2bf6d80c | 1150 | switch(iref+1){ |
fb65de21 | 1151 | case kNCl: |
2bf6d80c | 1152 | for(Int_t ig(0); ig<fgkNgraph[iref]; ig++){ |
fb65de21 | 1153 | arr->AddAt(g = new TGraphErrors(), ig); |
1154 | g->SetLineColor(ig+1); | |
1155 | g->SetMarkerColor(ig+1); | |
1156 | g->SetMarkerStyle(ig+20); | |
1157 | g->SetName(Form("s%d", ig)); | |
1158 | switch(ig){ | |
1159 | case 0: g->SetTitle("ALL"); break; | |
1160 | case 1: g->SetTitle("NEG"); break; | |
1161 | case 2: g->SetTitle("POS"); break; | |
1162 | default: g->SetTitle(AliPID::ParticleLatexName(ig-3)); break; | |
1163 | }; | |
1164 | } | |
1165 | break; | |
1166 | case kTRDmom: | |
2bf6d80c | 1167 | for(Int_t ig(0); ig<fgkNgraph[iref]; ig++){ |
fb65de21 | 1168 | arr->AddAt(g = new TGraphAsymmErrors(), ig); |
1169 | g->SetLineColor(ig+1); | |
1170 | g->SetMarkerColor(ig+1); | |
1171 | g->SetMarkerStyle(ig+20); | |
1172 | } | |
1173 | break; | |
1174 | case kPtRes: | |
2bf6d80c | 1175 | for(Int_t idx(0); idx<AliPID::kSPECIES; idx++){ |
fb65de21 | 1176 | Int_t ig(2*idx); |
1177 | arr->AddAt(g = new TGraphErrors(), ig); | |
1178 | g->SetLineColor(kRed-idx); | |
1179 | g->SetMarkerColor(kRed-idx); | |
1180 | g->SetMarkerStyle(20+idx); | |
1181 | g->SetNameTitle(Form("s%d", ig), Form("res %s", AliPID::ParticleLatexName(idx))); | |
1182 | arr->AddAt(g = new TGraphErrors(), ig+1); | |
1183 | g->SetLineColor(kBlue-idx); | |
1184 | g->SetMarkerColor(kBlue-idx); | |
1185 | g->SetMarkerStyle(20+idx); | |
1186 | g->SetNameTitle(Form("m%d", ig+1), Form("sys %s", AliPID::ParticleLatexName(idx))); | |
1187 | ||
1188 | ig+=10; | |
1189 | arr->AddAt(g = new TGraphErrors(), ig); | |
1190 | g->SetLineColor(kRed-idx); | |
1191 | g->SetMarkerColor(kRed-idx); | |
1192 | g->SetMarkerStyle(20+idx); | |
1193 | g->SetNameTitle(Form("s%d", ig), Form("sigma %s", AliPID::ParticleLatexName(idx))); | |
1194 | arr->AddAt(g = new TGraphErrors(), ig+1); | |
1195 | g->SetLineColor(kBlue-idx); | |
1196 | g->SetMarkerColor(kBlue-idx); | |
1197 | g->SetMarkerStyle(20+idx); | |
1198 | g->SetNameTitle(Form("m%d", ig+1), Form("mean %s", AliPID::ParticleLatexName(idx))); | |
1199 | } | |
1200 | break; | |
1201 | default: | |
2bf6d80c | 1202 | for(Int_t ig(0); ig<fgkNgraph[iref]; ig++){ |
fb65de21 | 1203 | arr->AddAt(g = new TGraphErrors(), ig); |
1204 | g->SetLineColor(ig+1); | |
1205 | g->SetMarkerColor(ig+1); | |
1206 | g->SetMarkerStyle(ig+20); | |
1207 | } | |
1208 | break; | |
1209 | } | |
1210 | } | |
1211 | } | |
1212 | TH1 *h1[2] = {NULL, NULL}; | |
1213 | TH2I *h2(NULL); | |
1214 | TAxis *ax(NULL); | |
1215 | ||
1216 | // No of clusters | |
1217 | if(!(h2 = (TH2I*)fHistos->At(kNCl))) return; | |
1218 | ax = h2->GetXaxis(); | |
1219 | arr = (TObjArray*)fResults->At(kNCl); | |
2bf6d80c | 1220 | |
fb65de21 | 1221 | // All tracks |
1222 | h1[0] = h2->ProjectionX("Ncl_px"); | |
1223 | TGraphErrors *ge=(TGraphErrors*)arr->At(0); | |
1224 | for(Int_t ib=2; ib<=ax->GetNbins(); ib++){ | |
1225 | ge->SetPoint(ib-2, ax->GetBinCenter(ib), h1[0]->GetBinContent(ib)); | |
1226 | } | |
2bf6d80c | 1227 | |
fb65de21 | 1228 | // All charged tracks |
1229 | TH1 *hNclCh[2] = {(TH1D*)h1[0]->Clone("NEG"), (TH1D*)h1[0]->Clone("POS")}; | |
1230 | hNclCh[0]->Reset();hNclCh[1]->Reset(); | |
1231 | for(Int_t is(1); is<=AliPID::kSPECIES; is++){ | |
1232 | hNclCh[0]->Add(h2->ProjectionX("Ncl_px", 2*is-1, 2*is-1)); // neg | |
1233 | hNclCh[1]->Add(h2->ProjectionX("Ncl_px", 2*is, 2*is)); // pos | |
1234 | } | |
1235 | if(Int_t(hNclCh[0]->GetEntries())){ | |
1236 | ge=(TGraphErrors*)arr->At(1); | |
1237 | for(Int_t ib=2; ib<=ax->GetNbins(); ib++){ | |
1238 | ge->SetPoint(ib-2, ax->GetBinCenter(ib), hNclCh[0]->GetBinContent(ib)); | |
1239 | } | |
1240 | } | |
2bf6d80c | 1241 | |
fb65de21 | 1242 | if(Int_t(hNclCh[1]->GetEntries())){ |
1243 | ge=(TGraphErrors*)arr->At(2); | |
1244 | for(Int_t ib=2; ib<=ax->GetNbins(); ib++){ | |
1245 | ge->SetPoint(ib-2, ax->GetBinCenter(ib), hNclCh[1]->GetBinContent(ib)); | |
1246 | } | |
1247 | } | |
1248 | // Species wise | |
1249 | for(Int_t is(1); is<=AliPID::kSPECIES; is++){ | |
1250 | h1[0] = h2->ProjectionX("Ncl_px", 2*is-1, 2*is); | |
1251 | if(!Int_t(h1[0]->GetEntries())) continue; | |
1252 | ge=(TGraphErrors*)arr->At(2+is); | |
1253 | for(Int_t ib=2; ib<=ax->GetNbins(); ib++){ | |
1254 | ge->SetPoint(ib-2, ax->GetBinCenter(ib), h1[0]->GetBinContent(ib)); | |
1255 | } | |
1256 | } | |
2bf6d80c | 1257 | |
fb65de21 | 1258 | fNRefFigures = 1; |
1259 | ||
1260 | // EFFICIENCY | |
1261 | // geometrical efficiency | |
1262 | if(!(h2 = (TH2I*)fHistos->At(kTRDstat))) return; | |
2bf6d80c | 1263 | arr = (TObjArray*)fResults->At(kTRDstat-1); |
fb65de21 | 1264 | h1[0] = h2->ProjectionX("checkESDx0", kTPCout, kTPCout); |
1265 | h1[1] = h2->ProjectionX("checkESDx1", kTRDin, kTRDin); | |
1266 | Process(h1, (TGraphErrors*)arr->At(0)); | |
1267 | delete h1[0];delete h1[1]; | |
1268 | // tracking efficiency | |
1269 | h1[0] = h2->ProjectionX("checkESDx0", kTRDin, kTRDin); | |
1270 | h1[1] = h2->ProjectionX("checkESDx1", kTRDout, kTRDout); | |
1271 | Process(h1, (TGraphErrors*)arr->At(1)); | |
1272 | delete h1[1]; | |
1273 | // PID efficiency | |
1274 | h1[1] = h2->ProjectionX("checkESDx1", kTRDpid, kTRDpid); | |
1275 | Process(h1, (TGraphErrors*)arr->At(2)); | |
1276 | delete h1[1]; | |
1277 | // Refit efficiency | |
1278 | h1[1] = h2->ProjectionX("checkESDx1", kTRDref, kTRDref); | |
1279 | Process(h1, (TGraphErrors*)arr->At(3)); | |
1280 | delete h1[1]; | |
1281 | fNRefFigures++; | |
1282 | ||
1283 | // ENERGY LOSS | |
1284 | if(!(h2 = dynamic_cast<TH2I*>(fHistos->At(kTRDmom)))) return; | |
2bf6d80c | 1285 | arr = (TObjArray*)fResults->At(kTRDmom-1); |
fb65de21 | 1286 | TGraphAsymmErrors *g06 = (TGraphAsymmErrors*)arr->At(0), *g09 = (TGraphAsymmErrors*)arr->At(1); |
1287 | ax=h2->GetXaxis(); | |
1288 | const Int_t nq(4); | |
1289 | const Double_t xq[nq] = {0.05, 0.2, 0.8, 0.95}; | |
1290 | Double_t yq[nq]; | |
1291 | for(Int_t ily=6; ily--;){ | |
1292 | h1[0] = h2->ProjectionX("checkESDp0", ily+1, ily+1); | |
1293 | h1[0]->GetQuantiles(nq,yq,xq); | |
1294 | g06->SetPoint(ily, Float_t(ily), ax->GetBinCenter(h1[0]->GetMaximumBin())); | |
1295 | g06->SetPointError(ily, 0., 0., TMath::Abs(yq[0]), yq[3]); | |
1296 | g09->SetPoint(ily, Float_t(ily), h1[0]->GetMean()); | |
1297 | g09->SetPointError(ily, 0., 0., TMath::Abs(yq[1]), yq[2]); | |
1298 | ||
1299 | //printf(" max[%f] mean[%f] q[%f %f %f %f]\n", ax->GetBinCenter(h1[0]->GetMaximumBin()), h1[0]->GetMean(), yq[0], yq[1], yq[2], yq[3]); | |
1300 | delete h1[0]; | |
1301 | } | |
1302 | fNRefFigures++; | |
1303 | // if(!HasMC()) return; | |
1304 | ||
1305 | // Pt RESOLUTION @ DCA | |
1306 | TH3S* h3(NULL); TGraphErrors *gg[2] = {NULL,NULL}; | |
1307 | if(!(h3 = dynamic_cast<TH3S*>(fHistos->At(kPtRes)))) return; | |
2bf6d80c | 1308 | arr = (TObjArray*)fResults->At(kPtRes-1); |
fb65de21 | 1309 | TAxis *az(h3->GetZaxis()); |
1310 | for(Int_t i(0); i<AliPID::kSPECIES; i++){ | |
1311 | Int_t idx(2*i); | |
1312 | az->SetRange(idx+1, idx+2); | |
1313 | gg[1] = (TGraphErrors*)arr->At(idx); | |
1314 | gg[0] = (TGraphErrors*)arr->At(idx+1); | |
1315 | Process2D((TH2*)h3->Project3D("yx"), gg); | |
1316 | ||
1317 | idx+=10; | |
1318 | az->SetRange(idx+1, idx+2); | |
1319 | gg[1] = (TGraphErrors*)arr->At(idx); | |
1320 | gg[0] = (TGraphErrors*)arr->At(idx+1); | |
1321 | Process2D((TH2*)h3->Project3D("yx"), gg); | |
1322 | } | |
1323 | fNRefFigures++; | |
1324 | ||
fb65de21 | 1325 | fNRefFigures++; |
2bf6d80c | 1326 | // 3x3 tracking summary canvases for every centrality class |
1327 | fNRefFigures++; | |
1328 | // 3x3 PID summary canvases for every centrality class | |
fb65de21 | 1329 | fNRefFigures++; |
2bf6d80c | 1330 | // 3x3 for centrality dependent pictures |
fb65de21 | 1331 | fNRefFigures++; |
33d501fa | 1332 | |
1333 | //DoTrending(); | |
fb65de21 | 1334 | } |
1335 | ||
1336 | //____________________________________________________________________ | |
1337 | Int_t AliTRDcheckESD::Pdg2Idx(Int_t pdg) const | |
1338 | { | |
1339 | // | |
1340 | // Helper function converting PDG code into AliPID index | |
1341 | // | |
1342 | switch(pdg){ | |
1343 | case kElectron: | |
1344 | case kPositron: return AliPID::kElectron; | |
1345 | case kMuonPlus: | |
1346 | case kMuonMinus: return AliPID::kMuon; | |
1347 | case kPiPlus: | |
1348 | case kPiMinus: return AliPID::kPion; | |
1349 | case kKPlus: | |
1350 | case kKMinus: return AliPID::kKaon; | |
1351 | case kProton: | |
1352 | case kProtonBar: return AliPID::kProton; | |
1353 | } | |
1354 | return -1; | |
1355 | } | |
1356 | ||
1357 | //____________________________________________________________________ | |
1358 | void AliTRDcheckESD::Process(TH1 **h1, TGraphErrors *g) | |
1359 | { | |
1360 | // Generic function to process one reference plot | |
1361 | ||
1362 | Int_t n1 = 0, n2 = 0, ip=0; | |
1363 | Double_t eff = 0.; | |
1364 | ||
1365 | TAxis *ax = h1[0]->GetXaxis(); | |
1366 | for(Int_t ib=1; ib<=ax->GetNbins(); ib++){ | |
1367 | if(!(n1 = (Int_t)h1[0]->GetBinContent(ib))) continue; | |
1368 | n2 = (Int_t)h1[1]->GetBinContent(ib); | |
1369 | eff = n2/Float_t(n1); | |
1370 | ||
1371 | ip=g->GetN(); | |
1372 | g->SetPoint(ip, ax->GetBinCenter(ib), eff); | |
1373 | g->SetPointError(ip, 0., n2 ? eff*TMath::Sqrt(1./n1+1./n2) : 0.); | |
1374 | } | |
1375 | } | |
1376 | //________________________________________________________ | |
1377 | void AliTRDcheckESD::Process2D(TH2 * const h2, TGraphErrors **g) | |
1378 | { | |
1379 | // | |
1380 | // Do the processing | |
1381 | // | |
1382 | ||
1383 | Int_t n = 0; | |
1384 | if((n=g[0]->GetN())) for(;n--;) g[0]->RemovePoint(n); | |
1385 | if((n=g[1]->GetN())) for(;n--;) g[1]->RemovePoint(n); | |
1386 | TF1 f("fg", "gaus", -3.,3.); | |
1387 | for(Int_t ibin = 1; ibin <= h2->GetNbinsX(); ibin++){ | |
1388 | Double_t x = h2->GetXaxis()->GetBinCenter(ibin); | |
1389 | TH1D *h = h2->ProjectionY("py", ibin, ibin); | |
1390 | if(h->GetEntries()<100) continue; | |
1391 | //AdjustF1(h, f); | |
1392 | ||
1393 | h->Fit(&f, "QN"); | |
1394 | Int_t ip = g[0]->GetN(); | |
1395 | g[0]->SetPoint(ip, x, f.GetParameter(1)); | |
1396 | g[0]->SetPointError(ip, 0., f.GetParError(1)); | |
1397 | g[1]->SetPoint(ip, x, f.GetParameter(2)); | |
1398 | g[1]->SetPointError(ip, 0., f.GetParError(2)); | |
1399 | } | |
1400 | return; | |
1401 | } | |
1402 | //____________________________________________________________________ | |
1403 | void AliTRDcheckESD::PrintStatus(ULong_t status) | |
1404 | { | |
1405 | // Dump track status to stdout | |
1406 | ||
1407 | printf("ITS[i(%d) o(%d) r(%d)] TPC[i(%d) o(%d) r(%d) p(%d)] TRD[i(%d) o(%d) r(%d) p(%d) s(%d)] HMPID[o(%d) p(%d)]\n" | |
1408 | ,Bool_t(status & AliESDtrack::kITSin) | |
1409 | ,Bool_t(status & AliESDtrack::kITSout) | |
1410 | ,Bool_t(status & AliESDtrack::kITSrefit) | |
1411 | ,Bool_t(status & AliESDtrack::kTPCin) | |
1412 | ,Bool_t(status & AliESDtrack::kTPCout) | |
1413 | ,Bool_t(status & AliESDtrack::kTPCrefit) | |
1414 | ,Bool_t(status & AliESDtrack::kTPCpid) | |
1415 | ,Bool_t(status & AliESDtrack::kTRDin) | |
1416 | ,Bool_t(status & AliESDtrack::kTRDout) | |
1417 | ,Bool_t(status & AliESDtrack::kTRDrefit) | |
1418 | ,Bool_t(status & AliESDtrack::kTRDpid) | |
1419 | ,Bool_t(status & AliESDtrack::kTRDStop) | |
1420 | ,Bool_t(status & AliESDtrack::kHMPIDout) | |
1421 | ,Bool_t(status & AliESDtrack::kHMPIDpid) | |
1422 | ); | |
1423 | } | |
1424 | ||
1425 | //____________________________________________________________________ | |
7698e7a4 | 1426 | TH1D* AliTRDcheckESD::Proj2D(TH2* hist) { |
fb65de21 | 1427 | // |
1428 | // project the PH vs Slice 2D-histo into a 1D histo | |
1429 | // | |
7698e7a4 | 1430 | /*TH1D* hProjection = new TH1F("hProjection","", hist->GetXaxis()->GetXbins()->GetSize()-1, |
1431 | hist->GetXaxis()->GetXbins()->GetArray());*/ | |
1432 | TH1D* hProjection = (TH1D*)hist->ProjectionX(Form("hProjection_%f", gRandom->Rndm())); | |
1433 | hProjection->Reset(); | |
1434 | //cout << "Proj2D: nbins = " << hist->GetXaxis()->GetXbins()->GetSize()-1 << endl; | |
fb65de21 | 1435 | TF1* fitLandau = new TF1("landauFunc","landau",0.,2000.); |
1436 | TH1D *hD; | |
1437 | for(Int_t iBin=1;iBin<=hist->GetXaxis()->GetNbins();iBin++) { | |
1438 | if(gROOT->FindObject("projection")) | |
1439 | delete gROOT->FindObject("projection"); | |
1440 | hD = (TH1D*)hist->ProjectionY("projection",iBin,iBin); | |
2bf6d80c | 1441 | hD->Rebin(4); |
1442 | if(hD->Integral()>10) { | |
fb65de21 | 1443 | fitLandau->SetParameter(1, hD->GetBinCenter(hD->GetMaximumBin())); |
7698e7a4 | 1444 | fitLandau->SetParLimits(1, 0.2*hD->GetBinCenter(hD->GetMaximumBin()), 3.0*hD->GetBinCenter(hD->GetMaximumBin())); |
2bf6d80c | 1445 | fitLandau->SetParameter(0, 1000.); |
7698e7a4 | 1446 | fitLandau->SetParLimits(0, 1., 10000000.); |
1447 | fitLandau->SetParameter(2, 0.5*hD->GetBinCenter(hD->GetMaximumBin())); | |
1448 | fitLandau->SetParLimits(2, 0.01*hD->GetBinCenter(hD->GetMaximumBin()), 1.0*hD->GetBinCenter(hD->GetMaximumBin())); | |
1449 | hD->Fit(fitLandau, "Q0", "", hD->GetXaxis()->GetXmin(), hD->GetXaxis()->GetXmax()); | |
1450 | hD->Fit(fitLandau, "Q0", "", hD->GetXaxis()->GetXmin(), hD->GetXaxis()->GetXmax()); | |
fb65de21 | 1451 | hProjection->SetBinContent(iBin, fitLandau->GetParameter(1)); |
7698e7a4 | 1452 | hProjection->SetBinError(iBin, fitLandau->GetParameter(2)); |
fb65de21 | 1453 | } |
1454 | else{ | |
1455 | hProjection->SetBinContent(iBin, 0); | |
1456 | hProjection->SetBinError(iBin, 0); | |
1457 | } | |
1458 | } | |
1459 | return hProjection; | |
1460 | } | |
1461 | ||
1462 | //____________________________________________________________________ | |
7698e7a4 | 1463 | TH2F* AliTRDcheckESD::Proj3D(TH3* hist, TH2* accMap, Int_t zbinLow, Int_t zbinHigh, Float_t &entries) { |
fb65de21 | 1464 | // |
1465 | // Project a 3D histogram to a 2D histogram in the Z axis interval [zbinLow,zbinHigh] | |
1466 | // Return the 2D histogram and also the number of entries into this projection (entries) | |
1467 | ||
1468 | Int_t nBinsX = hist->GetXaxis()->GetNbins(); // X and Y axis bins are assumed to be all equal | |
1469 | Float_t minX = hist->GetXaxis()->GetXmin(); | |
1470 | Float_t maxX = hist->GetXaxis()->GetXmax(); | |
1471 | Int_t nBinsY = hist->GetYaxis()->GetNbins(); | |
1472 | Float_t minY = hist->GetYaxis()->GetXmin(); | |
1473 | Float_t maxY = hist->GetYaxis()->GetXmax(); | |
1474 | Int_t nBinsZ = hist->GetZaxis()->GetNbins(); // Z axis bins (pt) might have different widths | |
fb65de21 | 1475 | |
1476 | TH2F* projHisto = (TH2F*)gROOT->FindObject("projHisto"); | |
1477 | if(projHisto) | |
1478 | projHisto->Reset(); | |
1479 | else | |
1480 | projHisto = new TH2F("projHisto", "projection", nBinsX, minX, maxX, nBinsY, minY, maxY); | |
1481 | ||
fb65de21 | 1482 | for(Int_t iZ=1; iZ<=nBinsZ; iZ++) { |
1483 | if(iZ<zbinLow) continue; | |
1484 | if(iZ>zbinHigh) continue; | |
1485 | for(Int_t iX=1; iX<=nBinsX; iX++) { | |
1486 | for(Int_t iY=1; iY<=nBinsY; iY++) { | |
7698e7a4 | 1487 | if(accMap) { |
1488 | if(accMap->GetBinContent(iX,iY)>0.1) | |
1489 | projHisto->SetBinContent(iX, iY, projHisto->GetBinContent(iX, iY)+hist->GetBinContent(iX,iY,iZ)); | |
1490 | } | |
1491 | else // no acc. cut | |
1492 | projHisto->SetBinContent(iX, iY, projHisto->GetBinContent(iX, iY)+hist->GetBinContent(iX,iY,iZ)); | |
1493 | // count only the entries which are inside the acceptance map | |
1494 | if(accMap) { | |
1495 | if(accMap->GetBinContent(iX,iY)>0.1) | |
1496 | entries+=hist->GetBinContent(iX,iY,iZ); | |
1497 | } | |
1498 | else // no acc. cut | |
1499 | entries+=hist->GetBinContent(iX,iY,iZ); | |
fb65de21 | 1500 | } |
1501 | } | |
1502 | } | |
1503 | return projHisto; | |
1504 | } | |
7698e7a4 | 1505 | |
1506 | //____________________________________________________________________ | |
1507 | void AliTRDcheckESD::CheckActiveSM(TH1D* phiProj, Bool_t activeSM[18]) { | |
1508 | // | |
1509 | // Check the active super-modules | |
1510 | // | |
1511 | Double_t entries[18] = {0.0}; | |
1512 | Double_t smPhiLimits[19]; | |
1513 | for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism; | |
1514 | for(Int_t phiBin=1; phiBin<=phiProj->GetXaxis()->GetNbins(); ++phiBin) { | |
1515 | Double_t phi = phiProj->GetBinCenter(phiBin); | |
1516 | Int_t sm = -1; | |
1517 | for(Int_t ism=0; ism<18; ++ism) | |
1518 | if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1]) sm = ism; | |
1519 | if(sm==-1) continue; | |
1520 | entries[sm] += phiProj->GetBinContent(phiBin); | |
1521 | } | |
1522 | Double_t avEntries = Double_t(phiProj->Integral())/18.0; | |
1523 | for(Int_t ism=0; ism<18; ++ism) | |
1524 | if(entries[ism]>0.5*avEntries) activeSM[ism] = kTRUE; | |
1525 | } | |
1526 | ||
fb65de21 | 1527 | //____________________________________________________________________ |
7698e7a4 | 1528 | TH1F* AliTRDcheckESD::EfficiencyTRD(TH3* tpc3D, TH3* trd3D, Bool_t useAcceptance) { |
fb65de21 | 1529 | // |
1530 | // Calculate the TRD-TPC matching efficiency as function of pt | |
1531 | // | |
7698e7a4 | 1532 | |
3fb80f44 | 1533 | if(!tpc3D || !trd3D) return NULL; |
fb65de21 | 1534 | Int_t nBinsZ = trd3D->GetZaxis()->GetNbins(); |
7698e7a4 | 1535 | // project everything on the eta-phi map to obtain an acceptance map |
fb65de21 | 1536 | Float_t nada = 0.; |
33d501fa | 1537 | TH2F *trdAcc = (useAcceptance ? (TH2F*)Proj3D(trd3D, 0x0, 1, nBinsZ, nada)->Clone(Form("trdAcc%f", gRandom->Rndm())) : 0x0); |
1538 | TH1D *phiProj = (trdAcc ? trdAcc->ProjectionY(Form("phiProj%f", gRandom->Rndm())) : 0x0); | |
7698e7a4 | 1539 | |
1540 | // prepare the acceptance map | |
1541 | Bool_t activeSM[18] = {kFALSE}; | |
1542 | Double_t smPhiLimits[19]; | |
1543 | for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism; | |
1544 | if(phiProj) { | |
1545 | CheckActiveSM(phiProj, activeSM); // get the active SMs | |
1546 | trdAcc->Reset(); | |
1547 | // Put 1 entry in every bin which belongs to an active SM | |
1548 | for(Int_t iY=1; iY<=trdAcc->GetYaxis()->GetNbins(); ++iY) { | |
1549 | Double_t phi = trdAcc->GetYaxis()->GetBinCenter(iY); | |
1550 | Bool_t isActive = kFALSE; | |
1551 | for(Int_t ism=0; ism<18; ++ism) { | |
1552 | if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1] && activeSM[ism]) { | |
1553 | isActive = kTRUE; | |
1554 | } | |
1555 | } | |
1556 | if(!isActive) continue; | |
1557 | for(Int_t iX=1; iX<=trdAcc->GetXaxis()->GetNbins(); ++iX) | |
1558 | if(trdAcc->GetXaxis()->GetBinCenter(iX)>=-0.85 && trdAcc->GetXaxis()->GetBinCenter(iX)<=0.85) trdAcc->SetBinContent(iX, iY, 1.0); | |
1559 | } // end for over Y(phi) bins | |
1560 | } // end if phiProj | |
1561 | ||
fb65de21 | 1562 | // get the bin limits from the Z axis of 3D histos |
1563 | Float_t *ptBinLimits = new Float_t[nBinsZ+1]; | |
1564 | for(Int_t i=1; i<=nBinsZ; i++) { | |
1565 | ptBinLimits[i-1] = trd3D->GetZaxis()->GetBinLowEdge(i); | |
1566 | } | |
1567 | ptBinLimits[nBinsZ] = trd3D->GetZaxis()->GetBinUpEdge(nBinsZ); | |
7698e7a4 | 1568 | |
33d501fa | 1569 | TH1F *efficiency = new TH1F(Form("eff%d", Int_t(1000000.0*gRandom->Rndm())), "TRD-TPC matching efficiency", nBinsZ, ptBinLimits); |
7698e7a4 | 1570 | |
fb65de21 | 1571 | // loop over Z bins |
33d501fa | 1572 | Bool_t effGood = kFALSE; |
fb65de21 | 1573 | for(Int_t i=1; i<=nBinsZ; i++) { |
1574 | Float_t tpcEntries = 0.0; Float_t trdEntries = 0.0; | |
1575 | Proj3D(tpc3D, trdAcc, i, i, tpcEntries); | |
1576 | Proj3D(trd3D, trdAcc, i, i, trdEntries); | |
1577 | Float_t ratio = 0; | |
1578 | if(tpcEntries>0) ratio = trdEntries/tpcEntries; | |
1579 | Float_t error = 0; | |
2bf6d80c | 1580 | if(tpcEntries>0 && trdEntries>0 && (tpcEntries-trdEntries)>=0.0) |
1581 | error = TMath::Sqrt(trdEntries*(tpcEntries-trdEntries)/tpcEntries/tpcEntries/tpcEntries); | |
33d501fa | 1582 | if(ratio>0.001) { |
fb65de21 | 1583 | efficiency->SetBinContent(i,ratio); |
1584 | efficiency->SetBinError(i,error); | |
33d501fa | 1585 | effGood = kTRUE; |
fb65de21 | 1586 | } |
1587 | } // end loop over Z bins | |
33d501fa | 1588 | if(!effGood) return 0x0; |
fb65de21 | 1589 | |
fb65de21 | 1590 | return efficiency; |
1591 | } | |
2bf6d80c | 1592 | |
7698e7a4 | 1593 | //__________________________________________________________________________________________________ |
33d501fa | 1594 | void AliTRDcheckESD::PlotCentSummaryFromCF(Double_t* trendValues, Bool_t useIsolatedBC, Bool_t cutTOFbc) { |
7698e7a4 | 1595 | // |
1596 | // Make the centrality summary figure from the CF container | |
1597 | // | |
1598 | if(!fCfContainer) return; | |
1599 | ||
1600 | TLatex* lat=new TLatex(); | |
1601 | lat->SetTextSize(0.06); | |
1602 | lat->SetTextColor(2); | |
1603 | ||
1604 | gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001); gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001); | |
1605 | gPad->Divide(3,3,0.,0.); | |
1606 | TList* l=gPad->GetListOfPrimitives(); | |
1607 | TVirtualPad* pad=0x0; | |
1608 | ||
33d501fa | 1609 | fCfContainer->SetRangeUser(kTrackDCAxy, -0.999, +0.999); |
1610 | fCfContainer->SetRangeUser(kTrackDCAz, -3.0, +3.0); | |
1611 | if(cutTOFbc) fCfContainer->SetRangeUser(kTrackTOFBC, 0.0, 0.0); | |
1612 | ||
1613 | // find all the isolated bunch crossings with entries | |
1614 | Bool_t isIsolated[3500]; | |
1615 | TH1D* tempTH1D = (TH1D*)fCfContainer->Project(0, kEventBC); | |
1616 | FindIsolatedBCs(tempTH1D, isIsolated); delete tempTH1D; | |
1617 | Int_t nIsolatedBC = 0; | |
1618 | for(Int_t ibc=0; ibc<3500; ++ibc) | |
1619 | if(isIsolated[ibc]) nIsolatedBC++; | |
1620 | ||
1621 | if(gROOT->FindObject("rangeEffPt")) delete gROOT->FindObject("rangeEffPt"); | |
1622 | TH2F* rangeEffPt=new TH2F("rangeEffPt", "",10,0.,10.,10,0.,1.3); | |
1623 | rangeEffPt->SetStats(kFALSE); | |
1624 | SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05); | |
1625 | SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05); | |
1626 | ||
7698e7a4 | 1627 | Int_t padsForEffs[5] = {0,3,6,1,4}; |
1628 | for(Int_t iCent=1; iCent<6; ++iCent) { | |
1629 | pad = ((TVirtualPad*)l->At(padsForEffs[iCent-1])); pad->cd(); | |
1630 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
1631 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 1632 | rangeEffPt->Draw(); |
1633 | TLine line; | |
1634 | line.SetLineStyle(2); | |
1635 | line.SetLineWidth(2); | |
1636 | line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7); | |
1637 | line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9); | |
7698e7a4 | 1638 | |
1639 | fCfContainer->SetRangeUser(kEventMult, Double_t(iCent), Double_t(iCent), kTRUE); | |
1640 | fCfContainer->SetRangeUser(kTrackCharge, +1.0, +1.0); // positive charges | |
1641 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0); | |
33d501fa | 1642 | |
7698e7a4 | 1643 | TH3D* h3PosTPC = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt); |
33d501fa | 1644 | if(h3PosTPC->GetEntries()<10) { |
1645 | delete h3PosTPC; | |
1646 | continue; | |
1647 | } | |
7698e7a4 | 1648 | TH3D* h3PosTRDall = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); |
1649 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0); // >= 4 TRD tracklets | |
1650 | TH3D* h3PosTRDtrk4 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1651 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0); // >= 5 TRD tracklets | |
1652 | TH3D* h3PosTRDtrk5 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1653 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0); // >= 6 TRD tracklets | |
1654 | TH3D* h3PosTRDtrk6 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1655 | ||
1656 | fCfContainer->SetRangeUser(kTrackCharge, -1.0, -1.0); // negative charges | |
1657 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0); // >= 0 TRD tracklets | |
1658 | TH3D* h3NegTPC = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt); | |
1659 | TH3D* h3NegTRDall = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1660 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0); // 4 TRD tracklets | |
1661 | TH3D* h3NegTRDtrk4 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1662 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0); // 5 TRD tracklets | |
1663 | TH3D* h3NegTRDtrk5 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1664 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0); // 6 TRD tracklets | |
1665 | TH3D* h3NegTRDtrk6 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1666 | ||
7698e7a4 | 1667 | TH1F* hEffPosAll = EfficiencyTRD(h3PosTPC, h3PosTRDall, kTRUE); |
1668 | TH1F* hEffPosTrk4 = EfficiencyTRD(h3PosTPC, h3PosTRDtrk4, kTRUE); | |
1669 | TH1F* hEffPosTrk5 = EfficiencyTRD(h3PosTPC, h3PosTRDtrk5, kTRUE); | |
1670 | TH1F* hEffPosTrk6 = EfficiencyTRD(h3PosTPC, h3PosTRDtrk6, kTRUE); | |
1671 | TH1F* hEffNegAll = EfficiencyTRD(h3NegTPC, h3NegTRDall, kTRUE); | |
1672 | TH1F* hEffNegTrk4 = EfficiencyTRD(h3NegTPC, h3NegTRDtrk4, kTRUE); | |
1673 | TH1F* hEffNegTrk5 = EfficiencyTRD(h3NegTPC, h3NegTRDtrk5, kTRUE); | |
1674 | TH1F* hEffNegTrk6 = EfficiencyTRD(h3NegTPC, h3NegTRDtrk6, kTRUE); | |
1675 | ||
33d501fa | 1676 | delete h3PosTPC; delete h3NegTPC; |
1677 | delete h3PosTRDall; delete h3PosTRDtrk4; delete h3PosTRDtrk5; delete h3PosTRDtrk6; | |
1678 | delete h3NegTRDall; delete h3NegTRDtrk4; delete h3NegTRDtrk5; delete h3NegTRDtrk6; | |
7698e7a4 | 1679 | |
33d501fa | 1680 | // get matching efficiencies for isolated bunches |
1681 | TH3D* h3TPCrefPos_IsolatedBC=0x0; TH3D* h3TPCrefNeg_IsolatedBC=0x0; | |
1682 | TH3D* h3TRDrefPosAll_IsolatedBC=0x0; TH3D* h3TRDrefPosTrk4_IsolatedBC=0x0; TH3D* h3TRDrefPosTrk5_IsolatedBC=0x0; TH3D* h3TRDrefPosTrk6_IsolatedBC=0x0; | |
1683 | TH3D* h3TRDrefNegAll_IsolatedBC=0x0; TH3D* h3TRDrefNegTrk4_IsolatedBC=0x0; TH3D* h3TRDrefNegTrk5_IsolatedBC=0x0; TH3D* h3TRDrefNegTrk6_IsolatedBC=0x0; | |
1684 | for(Int_t ibc=0; ibc<3500; ++ibc) { | |
1685 | if(!isIsolated[ibc]) continue; | |
1686 | fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc)); | |
1687 | ||
1688 | TH3D* tempTH3D; | |
1689 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0); | |
1690 | fCfContainer->SetRangeUser(kTrackCharge, +1.0, +1.0); // positive charges | |
1691 | tempTH3D = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt); | |
1692 | if(!h3TPCrefPos_IsolatedBC) h3TPCrefPos_IsolatedBC = tempTH3D; | |
1693 | else {h3TPCrefPos_IsolatedBC->Add(tempTH3D); delete tempTH3D;}; | |
1694 | tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1695 | if(!h3TRDrefPosAll_IsolatedBC) h3TRDrefPosAll_IsolatedBC = tempTH3D; | |
1696 | else {h3TRDrefPosAll_IsolatedBC->Add(tempTH3D); delete tempTH3D;} | |
1697 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0); | |
1698 | tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1699 | if(!h3TRDrefPosTrk4_IsolatedBC) h3TRDrefPosTrk4_IsolatedBC = tempTH3D; | |
1700 | else {h3TRDrefPosTrk4_IsolatedBC->Add(tempTH3D); delete tempTH3D;} | |
1701 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0); | |
1702 | tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1703 | if(!h3TRDrefPosTrk5_IsolatedBC) h3TRDrefPosTrk5_IsolatedBC = tempTH3D; | |
1704 | else {h3TRDrefPosTrk5_IsolatedBC->Add(tempTH3D); delete tempTH3D;} | |
1705 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0); | |
1706 | tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1707 | if(!h3TRDrefPosTrk6_IsolatedBC) h3TRDrefPosTrk6_IsolatedBC = tempTH3D; | |
1708 | else {h3TRDrefPosTrk6_IsolatedBC->Add(tempTH3D); delete tempTH3D;} | |
1709 | ||
1710 | fCfContainer->SetRangeUser(kTrackCharge, -1.0, -1.0); // negative charges | |
1711 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0); | |
1712 | tempTH3D = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt); | |
1713 | if(!h3TPCrefNeg_IsolatedBC) h3TPCrefNeg_IsolatedBC = tempTH3D; | |
1714 | else {h3TPCrefNeg_IsolatedBC->Add(tempTH3D); delete tempTH3D;} | |
1715 | tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1716 | if(!h3TRDrefNegAll_IsolatedBC) h3TRDrefNegAll_IsolatedBC = tempTH3D; | |
1717 | else {h3TRDrefNegAll_IsolatedBC->Add(tempTH3D); delete tempTH3D;} | |
1718 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0); | |
1719 | tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1720 | if(!h3TRDrefNegTrk4_IsolatedBC) h3TRDrefNegTrk4_IsolatedBC = tempTH3D; | |
1721 | else {h3TRDrefNegTrk4_IsolatedBC->Add(tempTH3D); delete tempTH3D;} | |
1722 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0); | |
1723 | tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1724 | if(!h3TRDrefNegTrk5_IsolatedBC) h3TRDrefNegTrk5_IsolatedBC = tempTH3D; | |
1725 | else {h3TRDrefNegTrk5_IsolatedBC->Add(tempTH3D); delete tempTH3D;} | |
1726 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0); | |
1727 | tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
1728 | if(!h3TRDrefNegTrk6_IsolatedBC) h3TRDrefNegTrk6_IsolatedBC = tempTH3D; | |
1729 | else {h3TRDrefNegTrk6_IsolatedBC->Add(tempTH3D); delete tempTH3D;} | |
1730 | } | |
1731 | fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0); | |
1732 | fCfContainer->SetRangeUser(kTrackCharge, -1.0, +1.0); | |
1733 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0); | |
1734 | ||
1735 | TH1F* hEffPosAll_IsolatedBC = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosAll_IsolatedBC, kTRUE); | |
1736 | TH1F* hEffPosTrk4_IsolatedBC = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosTrk4_IsolatedBC, kTRUE); | |
1737 | TH1F* hEffPosTrk5_IsolatedBC = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosTrk5_IsolatedBC, kTRUE); | |
1738 | TH1F* hEffPosTrk6_IsolatedBC = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosTrk6_IsolatedBC, kTRUE); | |
1739 | TH1F* hEffNegAll_IsolatedBC = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegAll_IsolatedBC, kTRUE); | |
1740 | TH1F* hEffNegTrk4_IsolatedBC = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegTrk4_IsolatedBC, kTRUE); | |
1741 | TH1F* hEffNegTrk5_IsolatedBC = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegTrk5_IsolatedBC, kTRUE); | |
1742 | TH1F* hEffNegTrk6_IsolatedBC = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegTrk6_IsolatedBC, kTRUE); | |
7698e7a4 | 1743 | |
33d501fa | 1744 | if(h3TPCrefPos_IsolatedBC) delete h3TPCrefPos_IsolatedBC; |
1745 | if(h3TPCrefNeg_IsolatedBC) delete h3TPCrefNeg_IsolatedBC; | |
1746 | if(h3TRDrefPosAll_IsolatedBC) delete h3TRDrefPosAll_IsolatedBC; | |
1747 | if(h3TRDrefPosTrk4_IsolatedBC) delete h3TRDrefPosTrk4_IsolatedBC; | |
1748 | if(h3TRDrefPosTrk5_IsolatedBC) delete h3TRDrefPosTrk5_IsolatedBC; | |
1749 | if(h3TRDrefPosTrk6_IsolatedBC) delete h3TRDrefPosTrk6_IsolatedBC; | |
1750 | if(h3TRDrefNegAll_IsolatedBC) delete h3TRDrefNegAll_IsolatedBC; | |
1751 | if(h3TRDrefNegTrk4_IsolatedBC) delete h3TRDrefNegTrk4_IsolatedBC; | |
1752 | if(h3TRDrefNegTrk5_IsolatedBC) delete h3TRDrefNegTrk5_IsolatedBC; | |
1753 | if(h3TRDrefNegTrk6_IsolatedBC) delete h3TRDrefNegTrk6_IsolatedBC; | |
1754 | ||
1755 | if(!useIsolatedBC) { | |
1756 | SetStyle(hEffPosAll, 1, kRed, 1, 24, kRed, 1); | |
1757 | SetStyle(hEffPosTrk4, 1, kRed, 1, 25, kRed, 1); | |
1758 | SetStyle(hEffPosTrk5, 1, kRed, 1, 26, kRed, 1); | |
1759 | SetStyle(hEffPosTrk6, 1, kRed, 1, 27, kRed, 1); | |
1760 | SetStyle(hEffNegAll, 1, kBlue, 1, 24, kBlue, 1); | |
1761 | SetStyle(hEffNegTrk4, 1, kBlue, 1, 25, kBlue, 1); | |
1762 | SetStyle(hEffNegTrk5, 1, kBlue, 1, 26, kBlue, 1); | |
1763 | SetStyle(hEffNegTrk6, 1, kBlue, 1, 27, kBlue, 1); | |
1764 | hEffPosAll->Draw("same"); | |
1765 | hEffNegAll->Draw("same"); | |
1766 | hEffPosTrk4->Draw("same"); | |
1767 | hEffNegTrk4->Draw("same"); | |
1768 | hEffPosTrk5->Draw("same"); | |
1769 | hEffNegTrk5->Draw("same"); | |
1770 | hEffPosTrk6->Draw("same"); | |
1771 | hEffNegTrk6->Draw("same"); | |
1772 | } | |
1773 | else { | |
1774 | if(nIsolatedBC>0) { | |
1775 | SetStyle(hEffPosAll_IsolatedBC, 1, kRed, 1, 24, kRed, 1); | |
1776 | SetStyle(hEffPosTrk4_IsolatedBC, 1, kRed, 1, 25, kRed, 1); | |
1777 | SetStyle(hEffPosTrk5_IsolatedBC, 1, kRed, 1, 26, kRed, 1); | |
1778 | SetStyle(hEffPosTrk6_IsolatedBC, 1, kRed, 1, 27, kRed, 1); | |
1779 | SetStyle(hEffNegAll_IsolatedBC, 1, kBlue, 1, 24, kBlue, 1); | |
1780 | SetStyle(hEffNegTrk4_IsolatedBC, 1, kBlue, 1, 25, kBlue, 1); | |
1781 | SetStyle(hEffNegTrk5_IsolatedBC, 1, kBlue, 1, 26, kBlue, 1); | |
1782 | SetStyle(hEffNegTrk6_IsolatedBC, 1, kBlue, 1, 27, kBlue, 1); | |
1783 | hEffPosAll_IsolatedBC->Draw("same"); | |
1784 | hEffNegAll_IsolatedBC->Draw("same"); | |
1785 | hEffPosTrk4_IsolatedBC->Draw("same"); | |
1786 | hEffNegTrk4_IsolatedBC->Draw("same"); | |
1787 | hEffPosTrk5_IsolatedBC->Draw("same"); | |
1788 | hEffNegTrk5_IsolatedBC->Draw("same"); | |
1789 | hEffPosTrk6_IsolatedBC->Draw("same"); | |
1790 | hEffNegTrk6_IsolatedBC->Draw("same"); | |
1791 | } | |
1792 | } | |
1793 | ||
7698e7a4 | 1794 | TLegend* leg=new TLegend(0.18, 0.7, 0.77, 0.89); |
1795 | if(iCent==1) { | |
1796 | leg->SetFillColor(0); | |
1797 | leg->SetNColumns(2); | |
1798 | leg->SetMargin(0.1); | |
1799 | leg->SetBorderSize(0); | |
33d501fa | 1800 | if(useIsolatedBC) { |
1801 | leg->SetHeader("Isolated bunch crossings"); | |
1802 | if(nIsolatedBC) { | |
1803 | leg->AddEntry(hEffPosAll_IsolatedBC, "pos. (#geq 1 tracklet)", "p"); | |
1804 | leg->AddEntry(hEffNegAll_IsolatedBC, "neg. (#geq 1 tracklet)", "p"); | |
1805 | leg->AddEntry(hEffPosTrk4_IsolatedBC, "pos. (4 tracklets)", "p"); | |
1806 | leg->AddEntry(hEffNegTrk4_IsolatedBC, "neg. (4 tracklets)", "p"); | |
1807 | leg->AddEntry(hEffPosTrk5_IsolatedBC, "pos. (5 tracklets)", "p"); | |
1808 | leg->AddEntry(hEffNegTrk5_IsolatedBC, "neg. (5 tracklets)", "p"); | |
1809 | leg->AddEntry(hEffPosTrk6_IsolatedBC, "pos. (6 tracklets)", "p"); | |
1810 | leg->AddEntry(hEffNegTrk6_IsolatedBC, "neg. (6 tracklets)", "p"); | |
1811 | } | |
1812 | } | |
1813 | else { | |
1814 | leg->SetHeader("All bunch crossings"); | |
1815 | leg->AddEntry(hEffPosAll, "pos. (#geq 1 tracklet)", "p"); | |
1816 | leg->AddEntry(hEffNegAll, "neg. (#geq 1 tracklet)", "p"); | |
1817 | leg->AddEntry(hEffPosTrk4, "pos. (4 tracklets)", "p"); | |
1818 | leg->AddEntry(hEffNegTrk4, "neg. (4 tracklets)", "p"); | |
1819 | leg->AddEntry(hEffPosTrk5, "pos. (5 tracklets)", "p"); | |
1820 | leg->AddEntry(hEffNegTrk5, "neg. (5 tracklets)", "p"); | |
1821 | leg->AddEntry(hEffPosTrk6, "pos. (6 tracklets)", "p"); | |
1822 | leg->AddEntry(hEffNegTrk6, "neg. (6 tracklets)", "p"); | |
1823 | } | |
7698e7a4 | 1824 | leg->Draw(); |
1825 | } | |
1826 | lat->DrawLatex(0.2, 1.32, Form("Centrality class %d", iCent)); | |
1827 | } // end for loop over multiplicity classes | |
1828 | ||
1829 | // Reset the modified user ranges of the CF container | |
33d501fa | 1830 | fCfContainer->SetRangeUser(kEventMult, 0, 6, kTRUE); |
7698e7a4 | 1831 | fCfContainer->SetRangeUser(kTrackCharge, -1.0, +1.0); |
1832 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0); | |
1833 | ||
1834 | // Cluster distributions in all multiplicity classes | |
1835 | pad = ((TVirtualPad*)l->At(2)); pad->cd(); | |
1836 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); | |
1837 | pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15); | |
1838 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 1839 | if(gROOT->FindObject("rangeNcls")) delete gROOT->FindObject("rangeNcls"); |
1840 | TH2F* rangeNcls = new TH2F("rangeNcls", "", 10, 0.0, 199.9, 10, 0.0, 1.199); | |
1841 | SetStyle(rangeNcls->GetXaxis(), "# TRD clusters", 0.07, 0.8, kTRUE, 0.05); | |
1842 | SetStyle(rangeNcls->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05); | |
1843 | rangeNcls->SetStats(kFALSE); | |
1844 | rangeNcls->Draw(); | |
1845 | ||
1846 | TH1D* hNcls[6]={0x0}; | |
1847 | TLegend* legCls=new TLegend(0.7, 0.75, 0.97, 0.97); | |
7698e7a4 | 1848 | legCls->SetBorderSize(0); |
1849 | legCls->SetFillColor(0); | |
1850 | legCls->SetMargin(0.15); | |
1851 | for(Int_t iCent=0; iCent<6; ++iCent) { | |
1852 | if(iCent>0) | |
1853 | fCfContainer->SetRangeUser(kEventMult, Double_t(iCent), Double_t(iCent), kTRUE); | |
33d501fa | 1854 | if(!useIsolatedBC) hNcls[iCent] = (TH1D*)fCfContainer->Project(1, kTrackTrdClusters); |
1855 | else{ | |
1856 | for(Int_t ibc=0; ibc<3500; ++ibc) { | |
1857 | if(!isIsolated[ibc]) continue; | |
1858 | fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc)); | |
1859 | tempTH1D = (TH1D*)fCfContainer->Project(1, kTrackTrdClusters); | |
1860 | if(!hNcls[iCent]) hNcls[iCent] = tempTH1D; | |
1861 | else {hNcls[iCent]->Add(tempTH1D); delete tempTH1D;} | |
1862 | } | |
1863 | fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0); | |
1864 | } | |
1865 | if(!hNcls[iCent]) continue; | |
7698e7a4 | 1866 | hNcls[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2); |
1867 | Double_t maximum = hNcls[iCent]->GetMaximum(); | |
1868 | if(maximum>1.0) | |
1869 | hNcls[iCent]->Scale(1.0/maximum); | |
7698e7a4 | 1870 | hNcls[iCent]->SetStats(kFALSE); |
1871 | hNcls[iCent]->SetTitle(""); | |
33d501fa | 1872 | hNcls[iCent]->SetLineWidth(2); |
7698e7a4 | 1873 | |
1874 | if(hNcls[iCent]->Integral()>0.01) { | |
33d501fa | 1875 | hNcls[iCent]->Draw("same"); |
7698e7a4 | 1876 | legCls->AddEntry(hNcls[iCent], (iCent==0 ? "all centralities" : Form("centrality class %d", iCent)), "l"); |
1877 | } | |
1878 | } | |
33d501fa | 1879 | if(useIsolatedBC) legCls->SetHeader("Isolated bunch crossings"); |
1880 | else legCls->SetHeader("All bunch crossings"); | |
7698e7a4 | 1881 | legCls->Draw(); |
33d501fa | 1882 | fCfContainer->SetRangeUser(kEventMult, 0.0, 6.0, kTRUE); |
7698e7a4 | 1883 | |
1884 | // Qtot vs P | |
1885 | pad = ((TVirtualPad*)l->At(5)); pad->cd(); | |
1886 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); | |
1887 | pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15); | |
1888 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 1889 | if(gROOT->FindObject("rangeQtot")) delete gROOT->FindObject("rangeQtot"); |
1890 | TH2F* rangeQtot = new TH2F("rangeQtot", "", 10, 0.0, 9.999, 10, 0.0, 1.199); | |
1891 | SetStyle(rangeQtot->GetXaxis(), "Q_{tot} (a.u.)", 0.07, 0.8, kTRUE, 0.05); | |
1892 | SetStyle(rangeQtot->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05); | |
1893 | rangeQtot->SetStats(kFALSE); | |
1894 | rangeQtot->Draw(); | |
1895 | ||
1896 | TH1D* hQtot[6]={0x0}; | |
1897 | TLegend* leg2=new TLegend(0.6, 0.7, 0.9, 0.97); | |
7698e7a4 | 1898 | leg2->SetFillColor(0); |
1899 | leg2->SetBorderSize(0); | |
1900 | for(Int_t iCent=0; iCent<6; ++iCent) { | |
1901 | if(iCent>0) | |
1902 | fCfContainer->SetRangeUser(kEventMult, Double_t(iCent), Double_t(iCent), kTRUE); | |
33d501fa | 1903 | if(useIsolatedBC) { |
1904 | for(Int_t ibc=0; ibc<3500; ++ibc) { | |
1905 | if(!isIsolated[ibc]) continue; | |
1906 | fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc)); | |
1907 | for(Int_t il=0; il<6; ++il) { | |
1908 | tempTH1D = (TH1D*)fCfContainer->Project(1, kTrackQtot+il); | |
1909 | if(!hQtot[iCent] && il==0) hQtot[iCent] = tempTH1D; | |
1910 | else {hQtot[iCent]->Add(tempTH1D); delete tempTH1D;} | |
1911 | } | |
1912 | } | |
1913 | fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0); | |
7698e7a4 | 1914 | } |
33d501fa | 1915 | else { |
1916 | for(Int_t il=0; il<6; ++il) { | |
1917 | tempTH1D = (TH1D*)fCfContainer->Project(1, kTrackQtot+il); | |
1918 | if(il==0) hQtot[iCent] = tempTH1D; | |
1919 | else hQtot[iCent]->Add(tempTH1D); | |
1920 | } | |
1921 | } // end if(useIsolatedBC) | |
7698e7a4 | 1922 | |
33d501fa | 1923 | if(!hQtot[iCent]) continue; |
7698e7a4 | 1924 | hQtot[iCent]->SetBinContent(1, 0); |
1925 | Double_t maximum = hQtot[iCent]->GetMaximum(); | |
1926 | if(maximum>1.0) | |
1927 | hQtot[iCent]->Scale(1.0/maximum); | |
1928 | hQtot[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2); | |
7698e7a4 | 1929 | hQtot[iCent]->SetStats(kFALSE); |
1930 | hQtot[iCent]->SetTitle(""); | |
33d501fa | 1931 | hQtot[iCent]->SetLineWidth(2); |
7698e7a4 | 1932 | if(hQtot[iCent]->Integral()>0.01) { |
1933 | hQtot[iCent]->Draw(iCent==0 ? "" : "same"); | |
1934 | leg2->AddEntry(hQtot[iCent], (iCent==0 ? "all centralities" : Form("centrality class %d", iCent)), "l"); | |
1935 | } | |
1936 | } | |
33d501fa | 1937 | if(useIsolatedBC) leg2->SetHeader("Isolated bunch crossings"); |
1938 | else leg2->SetHeader("All bunch crossings"); | |
7698e7a4 | 1939 | leg2->Draw(); |
1940 | fCfContainer->SetRangeUser(kEventMult, 0.0, 5.0, kTRUE); | |
33d501fa | 1941 | if(cutTOFbc) fCfContainer->SetRangeUser(kTrackTOFBC, -1000.0, +1000.0); // reset the cut on TOFbc |
7698e7a4 | 1942 | } |
1943 | ||
1944 | ||
2bf6d80c | 1945 | //_________________________________________________________________ |
33d501fa | 1946 | void AliTRDcheckESD::PlotTrackingSummaryFromCF(Int_t centralityClass, Double_t* trendValues, Bool_t useIsolatedBC, Bool_t cutTOFbc) { |
2bf6d80c | 1947 | |
33d501fa | 1948 | if(!fCfContainer) return; |
1949 | ||
7698e7a4 | 1950 | TLatex *lat=new TLatex(); |
2bf6d80c | 1951 | lat->SetTextSize(0.06); |
1952 | lat->SetTextColor(2); | |
7698e7a4 | 1953 | |
1954 | gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001); | |
1955 | gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001); | |
1956 | gPad->Divide(3,3,0.,0.); | |
1957 | TList* l=gPad->GetListOfPrimitives(); | |
1958 | ||
1959 | // eta-phi distr. for positive TPC tracks | |
1960 | TVirtualPad* pad = ((TVirtualPad*)l->At(0)); pad->cd(); | |
1961 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
1962 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
1963 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 1964 | |
1965 | fCfContainer->SetRangeUser(kTrackDCAxy, -0.999, +0.999); | |
1966 | fCfContainer->SetRangeUser(kTrackDCAz, -3.0, +3.0); | |
1967 | if(cutTOFbc) fCfContainer->SetRangeUser(kTrackTOFBC, 0.0, 0.0); | |
1968 | ||
1969 | // find all the isolated bunch crossings with entries | |
1970 | Bool_t isIsolated[3500]; | |
1971 | TH1D* tempTH1D = (TH1D*)fCfContainer->Project(0, kEventBC); | |
1972 | FindIsolatedBCs(tempTH1D, isIsolated); delete tempTH1D; | |
1973 | Int_t nIsolatedBC = 0; | |
1974 | for(Int_t ibc=0; ibc<3500; ++ibc) | |
1975 | if(isIsolated[ibc]) nIsolatedBC++; | |
7698e7a4 | 1976 | |
1977 | if(centralityClass>0) // select the multiplicity class | |
1978 | fCfContainer->SetRangeUser(kEventMult, Double_t(centralityClass), Double_t(centralityClass), kTRUE); | |
33d501fa | 1979 | |
1980 | TH2D* hTPCrefPos = 0x0; TH2D* hTRDrefPos = 0x0; TH2D* hTOFrefPos = 0x0; | |
1981 | TH2D* hTPCrefNeg = 0x0; TH2D* hTRDrefNeg = 0x0; TH2D* hTOFrefNeg = 0x0; | |
1982 | if(!useIsolatedBC) { | |
1983 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0); | |
1984 | fCfContainer->SetRangeUser(kTrackCharge, +1.0, +1.0); // positive charges | |
1985 | hTPCrefPos = (TH2D*)fCfContainer->Project(0, kTrackEta, kTrackPhi); | |
1986 | hTRDrefPos = (TH2D*)fCfContainer->Project(1, kTrackEta, kTrackPhi); | |
1987 | hTOFrefPos = (TH2D*)fCfContainer->Project(2, kTrackEta, kTrackPhi); | |
1988 | fCfContainer->SetRangeUser(kTrackCharge, -1.0, -1.0); // negative charges | |
1989 | hTPCrefNeg = (TH2D*)fCfContainer->Project(0, kTrackEta, kTrackPhi); | |
1990 | hTRDrefNeg = (TH2D*)fCfContainer->Project(1, kTrackEta, kTrackPhi); | |
1991 | hTOFrefNeg = (TH2D*)fCfContainer->Project(2, kTrackEta, kTrackPhi); | |
1992 | fCfContainer->SetRangeUser(kTrackCharge, -1.0, +1.0); // reset charge cut | |
1993 | } | |
1994 | ||
1995 | TH2D* hTPCrefPos_IsolatedBC=0x0; TH2D* hTPCrefNeg_IsolatedBC=0x0; | |
1996 | TH2D* hTRDrefPos_IsolatedBC=0x0; TH2D* hTRDrefNeg_IsolatedBC=0x0; | |
1997 | TH2D* hTOFrefPos_IsolatedBC=0x0; TH2D* hTOFrefNeg_IsolatedBC=0x0; | |
1998 | if(useIsolatedBC) { | |
1999 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0); | |
2000 | for(Int_t ibc=0; ibc<3500; ++ibc) { | |
2001 | if(!isIsolated[ibc]) continue; | |
2002 | fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc)); | |
2003 | fCfContainer->SetRangeUser(kTrackCharge, +1.0, +1.0); // positive charges | |
2004 | TH2D* tempTH2D; | |
2005 | tempTH2D = (TH2D*)fCfContainer->Project(0, kTrackEta, kTrackPhi); | |
2006 | if(!hTPCrefPos_IsolatedBC) hTPCrefPos_IsolatedBC = tempTH2D; | |
2007 | else {hTPCrefPos_IsolatedBC->Add(tempTH2D); delete tempTH2D;} | |
2008 | tempTH2D = (TH2D*)fCfContainer->Project(1, kTrackEta, kTrackPhi); | |
2009 | if(!hTRDrefPos_IsolatedBC) hTRDrefPos_IsolatedBC = tempTH2D; | |
2010 | else {hTRDrefPos_IsolatedBC->Add(tempTH2D); delete tempTH2D;} | |
2011 | tempTH2D = (TH2D*)fCfContainer->Project(2, kTrackEta, kTrackPhi); | |
2012 | if(!hTOFrefPos_IsolatedBC) hTOFrefPos_IsolatedBC = tempTH2D; | |
2013 | else {hTOFrefPos_IsolatedBC->Add(tempTH2D); delete tempTH2D;} | |
2014 | fCfContainer->SetRangeUser(kTrackCharge, -1.0, -1.0); // negative charges | |
2015 | tempTH2D = (TH2D*)fCfContainer->Project(0, kTrackEta, kTrackPhi); | |
2016 | if(!hTPCrefNeg_IsolatedBC) hTPCrefNeg_IsolatedBC = tempTH2D; | |
2017 | else {hTPCrefNeg_IsolatedBC->Add(tempTH2D); delete tempTH2D;} | |
2018 | tempTH2D = (TH2D*)fCfContainer->Project(1, kTrackEta, kTrackPhi); | |
2019 | if(!hTRDrefNeg_IsolatedBC) hTRDrefNeg_IsolatedBC = tempTH2D; | |
2020 | else {hTRDrefNeg_IsolatedBC->Add(tempTH2D); delete tempTH2D;} | |
2021 | tempTH2D = (TH2D*)fCfContainer->Project(2, kTrackEta, kTrackPhi); | |
2022 | if(!hTOFrefNeg_IsolatedBC) hTOFrefNeg_IsolatedBC = tempTH2D; | |
2023 | else {hTOFrefNeg_IsolatedBC->Add(tempTH2D); delete tempTH2D;} | |
2024 | } | |
2025 | fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.); // reset the BC range | |
2026 | fCfContainer->SetRangeUser(kTrackCharge, -1.0, +1.0); // reset charge cut | |
2027 | } | |
2028 | ||
2029 | if(gROOT->FindObject("rangeEtaPhi")) delete gROOT->FindObject("rangeEtaPhi"); | |
2030 | TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi", "", 10, -0.99, +0.99, 10, -3.4, +3.4); | |
2031 | SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05); | |
2032 | SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05); | |
2033 | rangeEtaPhi->SetStats(kFALSE); | |
7698e7a4 | 2034 | |
2035 | //---------------------------------------------- | |
2036 | // eta-phi efficiency for positive TRD tracks | |
2037 | pad = ((TVirtualPad*)l->At(0)); pad->cd(); | |
2038 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
2039 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
2040 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 2041 | rangeEtaPhi->Draw(); |
2042 | ||
2043 | if(useIsolatedBC) { | |
2044 | if(nIsolatedBC>0) { | |
2045 | TH2D* hTRDeffPos_IsolatedBC = (TH2D*)hTRDrefPos_IsolatedBC->Clone("hTRDeffPos_IsolatedBC"); | |
2046 | hTRDeffPos_IsolatedBC->Reset(); | |
2047 | hTRDeffPos_IsolatedBC->SetStats(kFALSE); | |
2048 | hTRDeffPos_IsolatedBC->Divide(hTRDrefPos_IsolatedBC, hTPCrefPos_IsolatedBC); | |
2049 | hTRDeffPos_IsolatedBC->SetMaximum(1.0); | |
2050 | hTRDeffPos_IsolatedBC->Draw("samecolz"); | |
2051 | } | |
2052 | } | |
2053 | else { | |
2054 | TH2D* hTRDeffPos = (TH2D*)hTRDrefPos->Clone("hTRDeffPos"); | |
2055 | hTRDeffPos->Reset(); | |
2056 | hTRDeffPos->SetStats(kFALSE); | |
2057 | hTRDeffPos->Divide(hTRDrefPos, hTPCrefPos); | |
2058 | hTRDeffPos->SetMaximum(1.0); | |
2059 | hTRDeffPos->Draw("samecolz"); | |
2060 | } | |
7698e7a4 | 2061 | lat->DrawLatex(-0.9, 3.6, "TPC-TRD matching for positive tracks"); |
2062 | DrawTRDGrid(); | |
2063 | ||
2064 | //---------------------------------------------- | |
2065 | // eta-phi efficiency for negative TRD tracks | |
2066 | pad = ((TVirtualPad*)l->At(3)); pad->cd(); | |
2067 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
2068 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
2069 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 2070 | rangeEtaPhi->Draw(); |
2071 | ||
2072 | if(useIsolatedBC) { | |
2073 | if(nIsolatedBC>0) { | |
2074 | TH2D* hTRDeffNeg_IsolatedBC = (TH2D*)hTRDrefNeg_IsolatedBC->Clone("hTRDeffNeg_IsolatedBC"); | |
2075 | hTRDeffNeg_IsolatedBC->Reset(); | |
2076 | hTRDeffNeg_IsolatedBC->SetStats(kFALSE); | |
2077 | hTRDeffNeg_IsolatedBC->Divide(hTRDrefNeg_IsolatedBC, hTPCrefNeg_IsolatedBC); | |
2078 | hTRDeffNeg_IsolatedBC->SetMaximum(1.0); | |
2079 | hTRDeffNeg_IsolatedBC->Draw("samecolz"); | |
2080 | } | |
2081 | } | |
2082 | else { | |
2083 | TH2D* hTRDeffNeg = (TH2D*)hTRDrefNeg->Clone("hTRDeffNeg"); | |
2084 | hTRDeffNeg->Reset(); | |
2085 | hTRDeffNeg->SetStats(kFALSE); | |
2086 | hTRDeffNeg->Divide(hTRDrefNeg, hTPCrefNeg); | |
2087 | hTRDeffNeg->SetMaximum(1.0); | |
2088 | hTRDeffNeg->Draw("samecolz"); | |
2089 | } | |
7698e7a4 | 2090 | lat->DrawLatex(-0.9, 3.6, "TPC-TRD matching for negative tracks"); |
33d501fa | 2091 | DrawTRDGrid(); |
7698e7a4 | 2092 | |
2093 | //---------------------------------------------- | |
2094 | // eta-phi TRD-TOF matching efficiency for positive tracks | |
2095 | pad = ((TVirtualPad*)l->At(1)); pad->cd(); | |
2096 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
2097 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
2098 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 2099 | rangeEtaPhi->Draw(); |
2100 | ||
2101 | if(useIsolatedBC) { | |
2102 | if(nIsolatedBC>0) { | |
2103 | TH2D* hTOFeffPos_IsolatedBC = (TH2D*)hTOFrefPos_IsolatedBC->Clone("hTOFeffPos_IsolatedBC"); | |
2104 | hTOFeffPos_IsolatedBC->Reset(); | |
2105 | hTOFeffPos_IsolatedBC->SetStats(kFALSE); | |
2106 | hTOFeffPos_IsolatedBC->Divide(hTOFrefPos_IsolatedBC, hTRDrefPos_IsolatedBC); | |
2107 | hTOFeffPos_IsolatedBC->SetMaximum(1.0); | |
2108 | hTOFeffPos_IsolatedBC->Draw("samecolz"); | |
2109 | } | |
2110 | } | |
2111 | else { | |
2112 | TH2D* hTOFeffPos = (TH2D*)hTOFrefPos->Clone("hTOFeffPos"); | |
2113 | hTOFeffPos->Reset(); | |
2114 | hTOFeffPos->SetStats(kFALSE); | |
2115 | hTOFeffPos->Divide(hTOFrefPos, hTRDrefPos); | |
2116 | hTOFeffPos->SetMaximum(1.0); | |
2117 | hTOFeffPos->Draw("samecolz"); | |
2118 | } | |
7698e7a4 | 2119 | lat->DrawLatex(-0.9, 3.6, "TRD-TOF matching for positive tracks"); |
2120 | DrawTRDGrid(); | |
2121 | ||
2122 | //---------------------------------------------- | |
2123 | // eta-phi TRD-TOF matching efficiency for negative tracks | |
2124 | pad = ((TVirtualPad*)l->At(4)); pad->cd(); | |
2125 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
2126 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
2127 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 2128 | rangeEtaPhi->Draw(); |
2129 | ||
2130 | if(useIsolatedBC) { | |
2131 | if(nIsolatedBC) { | |
2132 | TH2D* hTOFeffNeg_IsolatedBC = (TH2D*)hTOFrefNeg_IsolatedBC->Clone("hTOFeffNeg_IsolatedBC"); | |
2133 | hTOFeffNeg_IsolatedBC->Reset(); | |
2134 | hTOFeffNeg_IsolatedBC->SetStats(kFALSE); | |
2135 | hTOFeffNeg_IsolatedBC->Divide(hTOFrefNeg_IsolatedBC, hTRDrefNeg_IsolatedBC); | |
2136 | hTOFeffNeg_IsolatedBC->SetMaximum(1.0); | |
2137 | hTOFeffNeg_IsolatedBC->Draw("samecolz"); | |
2138 | } | |
2139 | } | |
2140 | else { | |
2141 | TH2D* hTOFeffNeg = (TH2D*)hTOFrefNeg->Clone("hTOFeffNeg"); | |
2142 | hTOFeffNeg->Reset(); | |
2143 | hTOFeffNeg->SetStats(kFALSE); | |
2144 | hTOFeffNeg->Divide(hTOFrefNeg, hTRDrefNeg); | |
2145 | hTOFeffNeg->SetMaximum(1.0); | |
2146 | hTOFeffNeg->Draw("samecolz"); | |
2147 | } | |
7698e7a4 | 2148 | lat->DrawLatex(-0.9, 3.6, "TRD-TOF matching for negative tracks"); |
2149 | DrawTRDGrid(); | |
2150 | ||
33d501fa | 2151 | if(hTRDrefPos) delete hTRDrefPos; if(hTPCrefPos) delete hTPCrefPos; if(hTOFrefPos) delete hTOFrefPos; |
2152 | if(hTRDrefNeg) delete hTRDrefNeg; if(hTPCrefNeg) delete hTPCrefNeg; if(hTOFrefNeg) delete hTOFrefNeg; | |
2153 | if(hTRDrefPos_IsolatedBC) delete hTRDrefPos_IsolatedBC; if(hTPCrefPos_IsolatedBC) delete hTPCrefPos_IsolatedBC; if(hTOFrefPos_IsolatedBC) delete hTOFrefPos_IsolatedBC; | |
2154 | if(hTRDrefNeg_IsolatedBC) delete hTRDrefNeg_IsolatedBC; if(hTPCrefNeg_IsolatedBC) delete hTPCrefNeg_IsolatedBC; if(hTOFrefNeg_IsolatedBC) delete hTOFrefNeg_IsolatedBC; | |
2155 | ||
2156 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0); | |
7698e7a4 | 2157 | fCfContainer->SetRangeUser(kTrackCharge, +1.0, +1.0); // positive charges |
2158 | TH3D* h3TPCrefPos = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt); | |
2159 | TH3D* h3TRDrefPosAll = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2160 | TH3D* h3TOFrefPosAll = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2161 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0); | |
2162 | TH3D* h3TRDrefPosTrk4 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2163 | TH3D* h3TOFrefPosTrk4 = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2164 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0); | |
2165 | TH3D* h3TRDrefPosTrk5 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2166 | TH3D* h3TOFrefPosTrk5 = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2167 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0); | |
2168 | TH3D* h3TRDrefPosTrk6 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2169 | TH3D* h3TOFrefPosTrk6 = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2170 | ||
2171 | fCfContainer->SetRangeUser(kTrackCharge, -1.0, -1.0); // negative charges | |
2172 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0); | |
2173 | TH3D* h3TPCrefNeg = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt); | |
2174 | TH3D* h3TRDrefNegAll = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2175 | TH3D* h3TOFrefNegAll = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2176 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0); | |
2177 | TH3D* h3TRDrefNegTrk4 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2178 | TH3D* h3TOFrefNegTrk4 = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2179 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0); | |
2180 | TH3D* h3TRDrefNegTrk5 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2181 | TH3D* h3TOFrefNegTrk5 = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2182 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0); | |
2183 | TH3D* h3TRDrefNegTrk6 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2184 | TH3D* h3TOFrefNegTrk6 = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
7698e7a4 | 2185 | fCfContainer->SetRangeUser(kTrackCharge, -1.0, +1.0); |
2186 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0); | |
2187 | ||
2188 | TH1F* hTRDEffPtPosAll = EfficiencyTRD(h3TPCrefPos, h3TRDrefPosAll, kTRUE); | |
2189 | TH1F* hTRDEffPtNegAll = EfficiencyTRD(h3TPCrefNeg, h3TRDrefNegAll, kTRUE); | |
2190 | TH1F* hTRDEffPtPosTrk4 = EfficiencyTRD(h3TPCrefPos, h3TRDrefPosTrk4, kTRUE); | |
2191 | TH1F* hTRDEffPtNegTrk4 = EfficiencyTRD(h3TPCrefNeg, h3TRDrefNegTrk4, kTRUE); | |
2192 | TH1F* hTRDEffPtPosTrk5 = EfficiencyTRD(h3TPCrefPos, h3TRDrefPosTrk5, kTRUE); | |
2193 | TH1F* hTRDEffPtNegTrk5 = EfficiencyTRD(h3TPCrefNeg, h3TRDrefNegTrk5, kTRUE); | |
2194 | TH1F* hTRDEffPtPosTrk6 = EfficiencyTRD(h3TPCrefPos, h3TRDrefPosTrk6, kTRUE); | |
2195 | TH1F* hTRDEffPtNegTrk6 = EfficiencyTRD(h3TPCrefNeg, h3TRDrefNegTrk6, kTRUE); | |
2196 | ||
2197 | TH1F* hTOFEffPtPosAll = EfficiencyTRD(h3TRDrefPosAll, h3TOFrefPosAll, kFALSE); | |
2198 | TH1F* hTOFEffPtNegAll = EfficiencyTRD(h3TRDrefNegAll, h3TOFrefNegAll, kFALSE); | |
2199 | TH1F* hTOFEffPtPosTrk4 = EfficiencyTRD(h3TRDrefPosTrk4, h3TOFrefPosTrk4, kFALSE); | |
2200 | TH1F* hTOFEffPtNegTrk4 = EfficiencyTRD(h3TRDrefNegTrk4, h3TOFrefNegTrk4, kFALSE); | |
2201 | TH1F* hTOFEffPtPosTrk5 = EfficiencyTRD(h3TRDrefPosTrk5, h3TOFrefPosTrk5, kFALSE); | |
2202 | TH1F* hTOFEffPtNegTrk5 = EfficiencyTRD(h3TRDrefNegTrk5, h3TOFrefNegTrk5, kFALSE); | |
2203 | TH1F* hTOFEffPtPosTrk6 = EfficiencyTRD(h3TRDrefPosTrk6, h3TOFrefPosTrk6, kFALSE); | |
2204 | TH1F* hTOFEffPtNegTrk6 = EfficiencyTRD(h3TRDrefNegTrk6, h3TOFrefNegTrk6, kFALSE); | |
2205 | ||
33d501fa | 2206 | delete h3TPCrefPos; delete h3TPCrefNeg; |
2207 | delete h3TRDrefPosAll; delete h3TRDrefPosTrk4; delete h3TRDrefPosTrk5; delete h3TRDrefPosTrk6; | |
2208 | delete h3TRDrefNegAll; delete h3TRDrefNegTrk4; delete h3TRDrefNegTrk5; delete h3TRDrefNegTrk6; | |
2209 | delete h3TOFrefPosAll; delete h3TOFrefPosTrk4; delete h3TOFrefPosTrk5; delete h3TOFrefPosTrk6; | |
2210 | delete h3TOFrefNegAll; delete h3TOFrefNegTrk4; delete h3TOFrefNegTrk5; delete h3TOFrefNegTrk6; | |
2211 | ||
2212 | TF1* funcConst = new TF1("constFunc", "[0]", 1.0, 3.0); | |
fe669adb | 2213 | if(trendValues && hTRDEffPtPosAll){ |
647cf3fa | 2214 | if(hTRDEffPtPosAll->Integral()>0.1) { |
2215 | hTRDEffPtPosAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0); | |
2216 | trendValues[0] = funcConst->GetParameter(0); | |
2217 | trendValues[1] = funcConst->GetParError(0); | |
2218 | } | |
fe669adb | 2219 | } |
2220 | if(trendValues && hTRDEffPtNegAll){ | |
647cf3fa | 2221 | if(hTRDEffPtNegAll->Integral()>0.1) { |
2222 | hTRDEffPtNegAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0); | |
2223 | trendValues[2] = funcConst->GetParameter(0); | |
2224 | trendValues[3] = funcConst->GetParError(0); | |
2225 | } | |
fe669adb | 2226 | } |
2227 | if(trendValues && hTOFEffPtPosAll){ | |
647cf3fa | 2228 | if(hTOFEffPtPosAll->Integral()>0.1) { |
2229 | hTOFEffPtPosAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0); | |
2230 | trendValues[4] = funcConst->GetParameter(0); | |
2231 | trendValues[5] = funcConst->GetParError(0); | |
2232 | } | |
fe669adb | 2233 | } |
2234 | if(trendValues && hTOFEffPtNegAll){ | |
647cf3fa | 2235 | if(hTOFEffPtNegAll->Integral()>0.1) { |
2236 | hTOFEffPtNegAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0); | |
2237 | trendValues[6] = funcConst->GetParameter(0); | |
2238 | trendValues[7] = funcConst->GetParError(0); | |
2239 | } | |
fe669adb | 2240 | } |
33d501fa | 2241 | // get matching efficiencies for isolated bunches |
2242 | TH3D* h3TPCrefPos_IsolatedBC=0x0; TH3D* h3TPCrefNeg_IsolatedBC=0x0; | |
2243 | TH3D* h3TRDrefPosAll_IsolatedBC=0x0; TH3D* h3TRDrefPosTrk4_IsolatedBC=0x0; TH3D* h3TRDrefPosTrk5_IsolatedBC=0x0; TH3D* h3TRDrefPosTrk6_IsolatedBC=0x0; | |
2244 | TH3D* h3TRDrefNegAll_IsolatedBC=0x0; TH3D* h3TRDrefNegTrk4_IsolatedBC=0x0; TH3D* h3TRDrefNegTrk5_IsolatedBC=0x0; TH3D* h3TRDrefNegTrk6_IsolatedBC=0x0; | |
2245 | TH3D* h3TOFrefPosAll_IsolatedBC=0x0; TH3D* h3TOFrefPosTrk4_IsolatedBC=0x0; TH3D* h3TOFrefPosTrk5_IsolatedBC=0x0; TH3D* h3TOFrefPosTrk6_IsolatedBC=0x0; | |
2246 | TH3D* h3TOFrefNegAll_IsolatedBC=0x0; TH3D* h3TOFrefNegTrk4_IsolatedBC=0x0; TH3D* h3TOFrefNegTrk5_IsolatedBC=0x0; TH3D* h3TOFrefNegTrk6_IsolatedBC=0x0; | |
2247 | for(Int_t ibc=0; ibc<3500; ++ibc) { | |
2248 | if(!isIsolated[ibc]) continue; | |
2249 | fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc)); | |
2250 | ||
2251 | TH3D* temp; | |
2252 | fCfContainer->SetRangeUser(kTrackCharge, +1.0, +1.0); // positive charges | |
2253 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0); | |
2254 | temp = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt); | |
2255 | if(!h3TPCrefPos_IsolatedBC) h3TPCrefPos_IsolatedBC = temp; | |
2256 | else {h3TPCrefPos_IsolatedBC->Add(temp); delete temp;} | |
2257 | temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2258 | if(!h3TRDrefPosAll_IsolatedBC) h3TRDrefPosAll_IsolatedBC = temp; | |
2259 | else {h3TRDrefPosAll_IsolatedBC->Add(temp); delete temp;} | |
2260 | temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2261 | if(!h3TOFrefPosAll_IsolatedBC) h3TOFrefPosAll_IsolatedBC = temp; | |
2262 | else {h3TOFrefPosAll_IsolatedBC->Add(temp); delete temp;} | |
2263 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0); | |
2264 | temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2265 | if(!h3TRDrefPosTrk4_IsolatedBC) h3TRDrefPosTrk4_IsolatedBC = temp; | |
2266 | else {h3TRDrefPosTrk4_IsolatedBC->Add(temp); delete temp;} | |
2267 | temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2268 | if(!h3TOFrefPosTrk4_IsolatedBC) h3TOFrefPosTrk4_IsolatedBC = temp; | |
2269 | else {h3TOFrefPosTrk4_IsolatedBC->Add(temp); delete temp;} | |
2270 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0); | |
2271 | temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2272 | if(!h3TRDrefPosTrk5_IsolatedBC) h3TRDrefPosTrk5_IsolatedBC = temp; | |
2273 | else {h3TRDrefPosTrk5_IsolatedBC->Add(temp); delete temp;} | |
2274 | temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2275 | if(!h3TOFrefPosTrk5_IsolatedBC) h3TOFrefPosTrk5_IsolatedBC = temp; | |
2276 | else {h3TOFrefPosTrk5_IsolatedBC->Add(temp); delete temp;} | |
2277 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0); | |
2278 | temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2279 | if(!h3TRDrefPosTrk6_IsolatedBC) h3TRDrefPosTrk6_IsolatedBC = temp; | |
2280 | else {h3TRDrefPosTrk6_IsolatedBC->Add(temp); delete temp;} | |
2281 | temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2282 | if(!h3TOFrefPosTrk6_IsolatedBC) h3TOFrefPosTrk6_IsolatedBC = temp; | |
2283 | else {h3TOFrefPosTrk6_IsolatedBC->Add(temp); delete temp;} | |
2284 | ||
2285 | fCfContainer->SetRangeUser(kTrackCharge, -1.0, -1.0); // negative charges | |
2286 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0); | |
2287 | temp = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt); | |
2288 | if(!h3TPCrefNeg_IsolatedBC) h3TPCrefNeg_IsolatedBC = temp; | |
2289 | else {h3TPCrefNeg_IsolatedBC->Add(temp); delete temp;} | |
2290 | temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2291 | if(!h3TRDrefNegAll_IsolatedBC) h3TRDrefNegAll_IsolatedBC = temp; | |
2292 | else {h3TRDrefNegAll_IsolatedBC->Add(temp); delete temp;} | |
2293 | temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2294 | if(!h3TOFrefNegAll_IsolatedBC) h3TOFrefNegAll_IsolatedBC = temp; | |
2295 | else {h3TOFrefNegAll_IsolatedBC->Add(temp); delete temp;} | |
2296 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0); | |
2297 | temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2298 | if(!h3TRDrefNegTrk4_IsolatedBC) h3TRDrefNegTrk4_IsolatedBC = temp; | |
2299 | else {h3TRDrefNegTrk4_IsolatedBC->Add(temp); delete temp;} | |
2300 | temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2301 | if(!h3TOFrefNegTrk4_IsolatedBC) h3TOFrefNegTrk4_IsolatedBC = temp; | |
2302 | else {h3TOFrefNegTrk4_IsolatedBC->Add(temp); delete temp;} | |
2303 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0); | |
2304 | temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2305 | if(!h3TRDrefNegTrk5_IsolatedBC) h3TRDrefNegTrk5_IsolatedBC = temp; | |
2306 | else {h3TRDrefNegTrk5_IsolatedBC->Add(temp); delete temp;} | |
2307 | temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2308 | if(!h3TOFrefNegTrk5_IsolatedBC) h3TOFrefNegTrk5_IsolatedBC = temp; | |
2309 | else {h3TOFrefNegTrk5_IsolatedBC->Add(temp); delete temp;} | |
2310 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0); | |
2311 | temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt); | |
2312 | if(!h3TRDrefNegTrk6_IsolatedBC) h3TRDrefNegTrk6_IsolatedBC = temp; | |
2313 | else {h3TRDrefNegTrk6_IsolatedBC->Add(temp); delete temp;} | |
2314 | temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt); | |
2315 | if(!h3TOFrefNegTrk6_IsolatedBC) h3TOFrefNegTrk6_IsolatedBC = temp; | |
2316 | else {h3TOFrefNegTrk6_IsolatedBC->Add(temp); delete temp;} | |
2317 | } | |
2318 | fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0); | |
2319 | fCfContainer->SetRangeUser(kTrackCharge, -1.0, +1.0); | |
2320 | fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0); | |
2321 | ||
2322 | TH1F* hTRDEffPtPosAll_IsolatedBC = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosAll_IsolatedBC, kTRUE); | |
2323 | TH1F* hTRDEffPtNegAll_IsolatedBC = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegAll_IsolatedBC, kTRUE); | |
2324 | TH1F* hTRDEffPtPosTrk4_IsolatedBC = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosTrk4_IsolatedBC, kTRUE); | |
2325 | TH1F* hTRDEffPtNegTrk4_IsolatedBC = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegTrk4_IsolatedBC, kTRUE); | |
2326 | TH1F* hTRDEffPtPosTrk5_IsolatedBC = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosTrk5_IsolatedBC, kTRUE); | |
2327 | TH1F* hTRDEffPtNegTrk5_IsolatedBC = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegTrk5_IsolatedBC, kTRUE); | |
2328 | TH1F* hTRDEffPtPosTrk6_IsolatedBC = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosTrk6_IsolatedBC, kTRUE); | |
2329 | TH1F* hTRDEffPtNegTrk6_IsolatedBC = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegTrk6_IsolatedBC, kTRUE); | |
2330 | ||
2331 | TH1F* hTOFEffPtPosAll_IsolatedBC = EfficiencyTRD(h3TRDrefPosAll_IsolatedBC, h3TOFrefPosAll_IsolatedBC, kFALSE); | |
2332 | TH1F* hTOFEffPtNegAll_IsolatedBC = EfficiencyTRD(h3TRDrefNegAll_IsolatedBC, h3TOFrefNegAll_IsolatedBC, kFALSE); | |
2333 | TH1F* hTOFEffPtPosTrk4_IsolatedBC = EfficiencyTRD(h3TRDrefPosTrk4_IsolatedBC, h3TOFrefPosTrk4_IsolatedBC, kFALSE); | |
2334 | TH1F* hTOFEffPtNegTrk4_IsolatedBC = EfficiencyTRD(h3TRDrefNegTrk4_IsolatedBC, h3TOFrefNegTrk4_IsolatedBC, kFALSE); | |
2335 | TH1F* hTOFEffPtPosTrk5_IsolatedBC = EfficiencyTRD(h3TRDrefPosTrk5_IsolatedBC, h3TOFrefPosTrk5_IsolatedBC, kFALSE); | |
2336 | TH1F* hTOFEffPtNegTrk5_IsolatedBC = EfficiencyTRD(h3TRDrefNegTrk5_IsolatedBC, h3TOFrefNegTrk5_IsolatedBC, kFALSE); | |
2337 | TH1F* hTOFEffPtPosTrk6_IsolatedBC = EfficiencyTRD(h3TRDrefPosTrk6_IsolatedBC, h3TOFrefPosTrk6_IsolatedBC, kFALSE); | |
2338 | TH1F* hTOFEffPtNegTrk6_IsolatedBC = EfficiencyTRD(h3TRDrefNegTrk6_IsolatedBC, h3TOFrefNegTrk6_IsolatedBC, kFALSE); | |
2339 | ||
2340 | if(h3TPCrefPos_IsolatedBC) delete h3TPCrefPos_IsolatedBC; if(h3TPCrefNeg_IsolatedBC) delete h3TPCrefNeg_IsolatedBC; | |
2341 | if(h3TRDrefPosAll_IsolatedBC) delete h3TRDrefPosAll_IsolatedBC; if(h3TRDrefPosTrk4_IsolatedBC) delete h3TRDrefPosTrk4_IsolatedBC; | |
2342 | if(h3TRDrefPosTrk5_IsolatedBC) delete h3TRDrefPosTrk5_IsolatedBC; if(h3TRDrefPosTrk6_IsolatedBC) delete h3TRDrefPosTrk6_IsolatedBC; | |
2343 | if(h3TRDrefNegAll_IsolatedBC) delete h3TRDrefNegAll_IsolatedBC; if(h3TRDrefNegTrk4_IsolatedBC) delete h3TRDrefNegTrk4_IsolatedBC; | |
2344 | if(h3TRDrefNegTrk5_IsolatedBC) delete h3TRDrefNegTrk5_IsolatedBC; if(h3TRDrefNegTrk6_IsolatedBC) delete h3TRDrefNegTrk6_IsolatedBC; | |
2345 | if(h3TOFrefPosAll_IsolatedBC) delete h3TOFrefPosAll_IsolatedBC; if(h3TOFrefPosTrk4_IsolatedBC) delete h3TOFrefPosTrk4_IsolatedBC; | |
2346 | if(h3TOFrefPosTrk5_IsolatedBC) delete h3TOFrefPosTrk5_IsolatedBC; if(h3TOFrefPosTrk6_IsolatedBC) delete h3TOFrefPosTrk6_IsolatedBC; | |
2347 | if(h3TOFrefNegAll_IsolatedBC) delete h3TOFrefNegAll_IsolatedBC; if(h3TOFrefNegTrk4_IsolatedBC) delete h3TOFrefNegTrk4_IsolatedBC; | |
2348 | if(h3TOFrefNegTrk5_IsolatedBC) delete h3TOFrefNegTrk5_IsolatedBC; if(h3TOFrefNegTrk6_IsolatedBC) delete h3TOFrefNegTrk6_IsolatedBC; | |
2349 | ||
2350 | if(trendValues && hTRDEffPtPosAll_IsolatedBC && hTRDEffPtPosAll_IsolatedBC->Integral()>0.1) { | |
2351 | hTRDEffPtPosAll_IsolatedBC->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0); | |
2352 | trendValues[18] = funcConst->GetParameter(0); | |
2353 | trendValues[19] = funcConst->GetParError(0); | |
2354 | } | |
2355 | if(trendValues && hTRDEffPtNegAll_IsolatedBC && hTRDEffPtNegAll_IsolatedBC->Integral()>0.1) { | |
2356 | hTRDEffPtNegAll_IsolatedBC->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0); | |
2357 | trendValues[20] = funcConst->GetParameter(0); | |
2358 | trendValues[21] = funcConst->GetParError(0); | |
2359 | } | |
2360 | if(trendValues && hTOFEffPtPosAll_IsolatedBC && hTOFEffPtPosAll_IsolatedBC->Integral()>0.1) { | |
2361 | hTOFEffPtPosAll_IsolatedBC->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0); | |
2362 | trendValues[22] = funcConst->GetParameter(0); | |
2363 | trendValues[23] = funcConst->GetParError(0); | |
2364 | } | |
2365 | if(trendValues && hTOFEffPtNegAll_IsolatedBC && hTOFEffPtNegAll_IsolatedBC->Integral()>0.1) { | |
2366 | hTOFEffPtNegAll_IsolatedBC->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0); | |
2367 | trendValues[24] = funcConst->GetParameter(0); | |
2368 | trendValues[25] = funcConst->GetParError(0); | |
2369 | } | |
7698e7a4 | 2370 | |
2371 | //--------------------------------------------------------- | |
2372 | // TPC-TRD matching efficiency vs pt | |
2373 | pad = ((TVirtualPad*)l->At(6)); pad->cd(); | |
2374 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); | |
2375 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
2376 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
2377 | ||
33d501fa | 2378 | if(gROOT->FindObject("rangeEffPt2")) delete gROOT->FindObject("rangeEffPt2"); |
2379 | TH2F* rangeEffPt=new TH2F("rangeEffPt2", "",10,0.,10.,10,0.,1.4); | |
2380 | rangeEffPt->SetStats(kFALSE); | |
2381 | SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05); | |
2382 | SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05); | |
2383 | rangeEffPt->Draw(); | |
2384 | lat->DrawLatex(0.2, 1.42, "TPC-TRD matching efficiency"); | |
7698e7a4 | 2385 | //++++++++++++++++++ |
2386 | TLine line; | |
2387 | line.SetLineStyle(2); | |
2388 | line.SetLineWidth(2); | |
33d501fa | 2389 | line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7); |
2390 | line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9); | |
7698e7a4 | 2391 | TLegend* leg=new TLegend(0.2, 0.7, 0.7, 0.89); |
2392 | leg->SetNColumns(2); | |
2393 | leg->SetMargin(0.15); | |
2394 | leg->SetBorderSize(0); | |
2395 | leg->SetFillColor(0); | |
2396 | ||
33d501fa | 2397 | if(!useIsolatedBC) { |
2398 | SetStyle(hTRDEffPtPosAll, 1, kRed, 1, 24, kRed, 1); | |
2399 | SetStyle(hTRDEffPtNegAll, 1, kBlue, 1, 24, kBlue, 1); | |
2400 | SetStyle(hTRDEffPtPosTrk4, 1, kRed, 1, 25, kRed, 1); | |
2401 | SetStyle(hTRDEffPtNegTrk4, 1, kBlue, 1, 25, kBlue, 1); | |
2402 | SetStyle(hTRDEffPtPosTrk5, 1, kRed, 1, 26, kRed, 1); | |
2403 | SetStyle(hTRDEffPtNegTrk5, 1, kBlue, 1, 26, kBlue, 1); | |
2404 | SetStyle(hTRDEffPtPosTrk6, 1, kRed, 1, 27, kRed, 1); | |
2405 | SetStyle(hTRDEffPtNegTrk6, 1, kBlue, 1, 27, kBlue, 1); | |
2406 | leg->SetHeader("All bunch crossings"); | |
2407 | hTRDEffPtPosAll->Draw("same"); leg->AddEntry(hTRDEffPtPosAll, "pos. (#geq 1 tracklet)", "p"); | |
2408 | hTRDEffPtNegAll->Draw("same"); leg->AddEntry(hTRDEffPtNegAll, "neg. (#geq 1 tracklet)", "p"); | |
2409 | hTRDEffPtPosTrk4->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk4, "pos. (4 tracklets)", "p"); | |
2410 | hTRDEffPtNegTrk4->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk4, "neg. (4 tracklets)", "p"); | |
2411 | hTRDEffPtPosTrk5->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk5, "pos. (5 tracklets)", "p"); | |
2412 | hTRDEffPtNegTrk5->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk5, "neg. (5 tracklets)", "p"); | |
2413 | hTRDEffPtPosTrk6->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk6, "pos. (6 tracklets)", "p"); | |
2414 | hTRDEffPtNegTrk6->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk6, "neg. (6 tracklets)", "p"); | |
2415 | } | |
2416 | else { | |
2417 | if(nIsolatedBC>0) { | |
2418 | SetStyle(hTRDEffPtPosAll_IsolatedBC, 1, kRed, 1, 24, kRed, 1); | |
2419 | SetStyle(hTRDEffPtNegAll_IsolatedBC, 1, kBlue, 1, 24, kBlue, 1); | |
2420 | SetStyle(hTRDEffPtPosTrk4_IsolatedBC, 1, kRed, 1, 25, kRed, 1); | |
2421 | SetStyle(hTRDEffPtNegTrk4_IsolatedBC, 1, kBlue, 1, 25, kBlue, 1); | |
2422 | SetStyle(hTRDEffPtPosTrk5_IsolatedBC, 1, kRed, 1, 26, kRed, 1); | |
2423 | SetStyle(hTRDEffPtNegTrk5_IsolatedBC, 1, kBlue, 1, 26, kBlue, 1); | |
2424 | SetStyle(hTRDEffPtPosTrk6_IsolatedBC, 1, kRed, 1, 27, kRed, 1); | |
2425 | SetStyle(hTRDEffPtNegTrk6_IsolatedBC, 1, kBlue, 1, 27, kBlue, 1); | |
2426 | leg->SetHeader("Isolated bunch crossings"); | |
2427 | hTRDEffPtPosAll_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtPosAll_IsolatedBC, "pos. (#geq 1 tracklet)", "p"); | |
2428 | hTRDEffPtNegAll_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtNegAll_IsolatedBC, "neg. (#geq 1 tracklet)", "p"); | |
2429 | hTRDEffPtPosTrk4_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk4_IsolatedBC, "pos. (4 tracklets)", "p"); | |
2430 | hTRDEffPtNegTrk4_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk4_IsolatedBC, "neg. (4 tracklets)", "p"); | |
2431 | hTRDEffPtPosTrk5_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk5_IsolatedBC, "pos. (5 tracklets)", "p"); | |
2432 | hTRDEffPtNegTrk5_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk5_IsolatedBC, "neg. (5 tracklets)", "p"); | |
2433 | hTRDEffPtPosTrk6_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk6_IsolatedBC, "pos. (6 tracklets)", "p"); | |
2434 | hTRDEffPtNegTrk6_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk6_IsolatedBC, "neg. (6 tracklets)", "p"); | |
2435 | } | |
2436 | } | |
7698e7a4 | 2437 | |
33d501fa | 2438 | leg->Draw(); |
7698e7a4 | 2439 | |
2440 | //--------------------------------------------------------- | |
2441 | // TRD-TOF matching efficiency vs pt | |
2442 | pad = ((TVirtualPad*)l->At(7)); pad->cd(); | |
2443 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); | |
2444 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
2445 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
2446 | ||
33d501fa | 2447 | rangeEffPt->Draw(); |
2448 | lat->DrawLatex(0.2, 1.42, "TRD-TOF matching efficiency"); | |
2449 | ||
2450 | if(!useIsolatedBC) { | |
2451 | SetStyle(hTOFEffPtPosAll, 1, kRed, 1, 24, kRed, 1); | |
2452 | SetStyle(hTOFEffPtPosTrk4, 1, kRed, 1, 25, kRed, 1); | |
2453 | SetStyle(hTOFEffPtPosTrk5, 1, kRed, 1, 26, kRed, 1); | |
2454 | SetStyle(hTOFEffPtPosTrk6, 1, kRed, 1, 27, kRed, 1); | |
2455 | SetStyle(hTOFEffPtNegAll, 1, kBlue, 1, 24, kBlue, 1); | |
2456 | SetStyle(hTOFEffPtNegTrk4, 1, kBlue, 1, 25, kBlue, 1); | |
2457 | SetStyle(hTOFEffPtNegTrk5, 1, kBlue, 1, 26, kBlue, 1); | |
2458 | SetStyle(hTOFEffPtNegTrk6, 1, kBlue, 1, 27, kBlue, 1); | |
2459 | hTOFEffPtPosAll->Draw("same"); | |
2460 | hTOFEffPtPosTrk4->Draw("same"); | |
2461 | hTOFEffPtPosTrk5->Draw("same"); | |
2462 | hTOFEffPtPosTrk6->Draw("same"); | |
2463 | hTOFEffPtNegAll->Draw("same"); | |
2464 | hTOFEffPtNegTrk4->Draw("same"); | |
2465 | hTOFEffPtNegTrk5->Draw("same"); | |
2466 | hTOFEffPtNegTrk6->Draw("same"); | |
2467 | } | |
2468 | else { | |
2469 | if(nIsolatedBC>0) { | |
2470 | SetStyle(hTOFEffPtPosAll_IsolatedBC, 1, kRed, 1, 24, kRed, 1); | |
2471 | SetStyle(hTOFEffPtPosTrk4_IsolatedBC, 1, kRed, 1, 25, kRed, 1); | |
2472 | SetStyle(hTOFEffPtPosTrk5_IsolatedBC, 1, kRed, 1, 26, kRed, 1); | |
2473 | SetStyle(hTOFEffPtPosTrk6_IsolatedBC, 1, kRed, 1, 27, kRed, 1); | |
2474 | SetStyle(hTOFEffPtNegAll_IsolatedBC, 1, kBlue, 1, 24, kBlue, 1); | |
2475 | SetStyle(hTOFEffPtNegTrk4_IsolatedBC, 1, kBlue, 1, 25, kBlue, 1); | |
2476 | SetStyle(hTOFEffPtNegTrk5_IsolatedBC, 1, kBlue, 1, 26, kBlue, 1); | |
2477 | SetStyle(hTOFEffPtNegTrk6_IsolatedBC, 1, kBlue, 1, 27, kBlue, 1); | |
2478 | hTOFEffPtPosAll_IsolatedBC->Draw("same"); | |
2479 | hTOFEffPtPosTrk4_IsolatedBC->Draw("same"); | |
2480 | hTOFEffPtPosTrk5_IsolatedBC->Draw("same"); | |
2481 | hTOFEffPtPosTrk6_IsolatedBC->Draw("same"); | |
2482 | hTOFEffPtNegAll_IsolatedBC->Draw("same"); | |
2483 | hTOFEffPtNegTrk4_IsolatedBC->Draw("same"); | |
2484 | hTOFEffPtNegTrk5_IsolatedBC->Draw("same"); | |
2485 | hTOFEffPtNegTrk6_IsolatedBC->Draw("same"); | |
2486 | } | |
2487 | } | |
2488 | ||
7698e7a4 | 2489 | //----------------------------------------------------- |
2490 | // <ntracklets> vs (phi,eta) | |
2491 | pad = ((TVirtualPad*)l->At(2)); pad->cd(); | |
2492 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
2493 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
2494 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
2495 | ||
33d501fa | 2496 | rangeEtaPhi->Draw(); |
2497 | lat->DrawLatex(-0.9, 3.6, "TRD <N_{tracklets}>"); | |
2498 | ||
7698e7a4 | 2499 | TH3D* hNtracklets = (TH3D*)fCfContainer->Project(1, kTrackPhi, kTrackEta, kTrackTrdTracklets); |
33d501fa | 2500 | TH3D* hNtracklets_IsolatedBC=0x0; |
2501 | for(Int_t ibc=0; ibc<3500; ++ibc) { | |
2502 | if(!isIsolated[ibc]) continue; | |
2503 | fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc)); | |
2504 | TH3D* temp = (TH3D*)fCfContainer->Project(1, kTrackPhi, kTrackEta, kTrackTrdTracklets); | |
2505 | if(!hNtracklets_IsolatedBC) hNtracklets_IsolatedBC = temp; | |
2506 | else {hNtracklets_IsolatedBC->Add(temp); delete temp;} | |
2507 | } | |
2508 | fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0); // reset the BC range | |
2509 | ||
2510 | TProfile2D* hNtrackletsProf=0x0; | |
2511 | if(useIsolatedBC) { | |
2512 | if(nIsolatedBC>0) | |
2513 | hNtrackletsProf = hNtracklets_IsolatedBC->Project3DProfile(); | |
2514 | } | |
2515 | else hNtrackletsProf = hNtracklets->Project3DProfile(); | |
2516 | delete hNtracklets; if(hNtracklets_IsolatedBC) delete hNtracklets_IsolatedBC; | |
7698e7a4 | 2517 | if(hNtrackletsProf) { |
2518 | hNtrackletsProf->SetStats(kFALSE); | |
7698e7a4 | 2519 | hNtrackletsProf->SetMinimum(0.); |
2520 | hNtrackletsProf->SetMaximum(6.); | |
33d501fa | 2521 | hNtrackletsProf->Draw("samecolz"); |
7698e7a4 | 2522 | DrawTRDGrid(); |
2523 | } | |
2524 | ||
33d501fa | 2525 | // calculate the trend value for tracklets/track |
2526 | TH2D* hNtrackletsVsP = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackTrdTracklets); | |
2527 | if(trendValues && hNtrackletsVsP && hNtrackletsVsP->GetEntries()>0.1) { | |
2528 | TProfile* hNtrackletsVsPprof = hNtrackletsVsP->ProfileX("hNtrackletsVsPprof"); | |
2529 | hNtrackletsVsPprof->Fit(funcConst, "QME0", "goff", 1.0, 3.0); | |
2530 | trendValues[8] = funcConst->GetParameter(0); | |
2531 | trendValues[9] = funcConst->GetParError(0); | |
2532 | delete hNtrackletsVsP; | |
2533 | } | |
2534 | TH2D* hNtrackletsVsP_IsolatedBC=0x0; | |
2535 | for(Int_t ibc=0; ibc<3500; ++ibc) { | |
2536 | if(!isIsolated[ibc]) continue; | |
2537 | fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc)); | |
2538 | TH2D* temp = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackTrdTracklets); | |
2539 | if(!hNtrackletsVsP_IsolatedBC) hNtrackletsVsP_IsolatedBC = temp; | |
2540 | else {hNtrackletsVsP_IsolatedBC->Add(temp); delete temp;} | |
2541 | } | |
2542 | fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0); // reset the BC range | |
2543 | if(trendValues && hNtrackletsVsP_IsolatedBC && hNtrackletsVsP_IsolatedBC->GetEntries()>0.1) { | |
2544 | TProfile* hNtrackletsVsPprof_IsolatedBC = hNtrackletsVsP_IsolatedBC->ProfileX("hNtrackletsVsPprof_IsolatedBC"); | |
2545 | hNtrackletsVsPprof_IsolatedBC->Fit(funcConst, "QME0", "goff", 1.0, 3.0); | |
2546 | trendValues[26] = funcConst->GetParameter(0); | |
2547 | trendValues[27] = funcConst->GetParError(0); | |
2548 | delete hNtrackletsVsPprof_IsolatedBC; | |
2549 | } | |
2550 | ||
7698e7a4 | 2551 | //-------------------------------------------------------------- |
2552 | // Nclusters per TRD track vs momentum | |
2553 | pad = ((TVirtualPad*)l->At(5)); pad->cd(); | |
2554 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.12); | |
2555 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
2556 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
2557 | pad->SetLogz(); | |
2558 | ||
33d501fa | 2559 | if(gROOT->FindObject("rangeNclsP")) delete gROOT->FindObject("rangeNclsP"); |
2560 | TH2F* rangeNclsP = new TH2F("rangeNclsP", "", 10, 0.0, 11.99, 10, 0.0, 199.0); | |
2561 | SetStyle(rangeNclsP->GetXaxis(), "p [GeV/c]", 0.07, 0.8, kTRUE, 0.05); | |
2562 | SetStyle(rangeNclsP->GetYaxis(), "#clusters", 0.07, 0.8, kTRUE, 0.05); | |
2563 | rangeNclsP->SetStats(kFALSE); | |
2564 | rangeNclsP->Draw(); | |
2565 | lat->DrawLatex(1.0, 205., "TRD Clusters / track"); | |
2566 | ||
7698e7a4 | 2567 | TH2D* hNclsVsP = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackTrdClusters); |
33d501fa | 2568 | TH2D* hNclsVsP_IsolatedBC=0x0; |
2569 | for(Int_t ibc=0; ibc<3500; ++ibc) { | |
2570 | if(!isIsolated[ibc]) continue; | |
2571 | fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc)); | |
2572 | TH2D* temp = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackTrdClusters); | |
2573 | if(!hNclsVsP_IsolatedBC) hNclsVsP_IsolatedBC = temp; | |
2574 | else {hNclsVsP_IsolatedBC->Add(temp); delete temp;} | |
2575 | } | |
2576 | fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0); // reset the BC range | |
7698e7a4 | 2577 | |
33d501fa | 2578 | if(useIsolatedBC && hNclsVsP_IsolatedBC) { |
2579 | hNclsVsP_IsolatedBC->SetStats(kFALSE); | |
2580 | hNclsVsP_IsolatedBC->Draw("samecolz"); | |
2581 | } | |
2582 | if(!useIsolatedBC && hNclsVsP) { | |
7698e7a4 | 2583 | hNclsVsP->SetStats(kFALSE); |
33d501fa | 2584 | hNclsVsP->Draw("samecolz"); |
7698e7a4 | 2585 | } |
33d501fa | 2586 | |
2587 | if(trendValues && hNclsVsP && hNclsVsP->GetEntries()>10) { | |
2588 | TProfile* hNclsVsPprof = hNclsVsP->ProfileX("hNclsVsPprof"); | |
2589 | hNclsVsPprof->Fit(funcConst, "QME0", "goff", 1.0, 3.0); | |
2590 | trendValues[10] = funcConst->GetParameter(0); | |
2591 | trendValues[11] = funcConst->GetParError(0); | |
2592 | } | |
2593 | if(trendValues && hNclsVsP_IsolatedBC && hNclsVsP_IsolatedBC->GetEntries()>10) { | |
2594 | TProfile* hNclsVsPprof_IsolatedBC = hNclsVsP_IsolatedBC->ProfileX("hNclsVsPprof_IsolateBC"); | |
2595 | hNclsVsPprof_IsolatedBC->Fit(funcConst, "QME0", "goff", 1.0, 3.0); | |
2596 | trendValues[28] = funcConst->GetParameter(0); | |
2597 | trendValues[29] = funcConst->GetParError(0); | |
2598 | } | |
2599 | ||
7698e7a4 | 2600 | //-------------------------------------------------------------- |
2601 | // TRD-TPC and TOF-TRD matching efficiency vs bunch crossing | |
2602 | pad = ((TVirtualPad*)l->At(8)); pad->cd(); | |
2603 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); | |
2604 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
2605 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
2606 | ||
2607 | TH1D* phiProj = (TH1D*)fCfContainer->Project(1, kTrackPhi); | |
2608 | Double_t smPhiLimits[19]; | |
2609 | Bool_t activeSM[18] = {kFALSE}; | |
2610 | for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism; | |
2611 | CheckActiveSM(phiProj, activeSM); | |
2612 | for(Int_t ism=0; ism<18; ++ism) cout << "sm " << ism << " is active : " << (activeSM[ism] ? "yes" : "no") << endl; | |
2613 | ||
2614 | fCfContainer->SetRangeUser(kTrackPt, 1.01, 2.99); // 1.0 < pt < 3.0 GeV/c | |
2615 | TH2D* hTPCPhiBC = (TH2D*)fCfContainer->Project(0, kEventBC, kTrackPhi); | |
2616 | TH2D* hTRDPhiBC = (TH2D*)fCfContainer->Project(1, kEventBC, kTrackPhi); | |
2617 | TH2D* hTOFPhiBC = (TH2D*)fCfContainer->Project(2, kEventBC, kTrackPhi); | |
2618 | TH1D* projectionBC = (TH1D*)fCfContainer->Project(0, kEventBC); | |
2619 | fCfContainer->SetRangeUser(kTrackPt, 0.0, 100.0); // reset the pt range | |
2620 | TH1D* hTRDEffBC = new TH1D("hTRDEffBC", "", hTPCPhiBC->GetXaxis()->GetNbins(), hTPCPhiBC->GetXaxis()->GetXmin(), hTPCPhiBC->GetXaxis()->GetXmax()); | |
2621 | TH1D* hTOFEffBC = new TH1D("hTOFEffBC", "", hTPCPhiBC->GetXaxis()->GetNbins(), hTPCPhiBC->GetXaxis()->GetXmin(), hTPCPhiBC->GetXaxis()->GetXmax()); | |
2622 | ||
2623 | for(Int_t bcBin=1; bcBin<=hTPCPhiBC->GetXaxis()->GetNbins(); ++bcBin) { | |
2624 | if(projectionBC->GetBinContent(bcBin)<0.1) continue; | |
2625 | Double_t tpcEntries = 0.0; Double_t trdEntries = 0.0; Double_t tofEntries = 0.0; | |
2626 | for(Int_t phiBin=1; phiBin<=hTPCPhiBC->GetYaxis()->GetNbins(); ++phiBin) { | |
2627 | Double_t phi = hTPCPhiBC->GetYaxis()->GetBinCenter(phiBin); | |
2628 | for(Int_t ism=0; ism<18; ++ism) { | |
2629 | if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1] && activeSM[ism]) { | |
2630 | tpcEntries += hTPCPhiBC->GetBinContent(bcBin, phiBin); | |
2631 | trdEntries += hTRDPhiBC->GetBinContent(bcBin, phiBin); | |
2632 | tofEntries += hTOFPhiBC->GetBinContent(bcBin, phiBin); | |
2633 | } | |
2634 | } // end loop over super-modules | |
2635 | } // end loop over phi bins | |
2636 | hTRDEffBC->SetBinContent(bcBin, (tpcEntries>0.01 ? trdEntries/tpcEntries : 0.0)); | |
2637 | if(tpcEntries>0.01 && trdEntries>0.01 && (tpcEntries-trdEntries)>=0.01) | |
2638 | hTRDEffBC->SetBinError(bcBin, TMath::Sqrt(trdEntries*(tpcEntries-trdEntries)/tpcEntries/tpcEntries/tpcEntries)); | |
2639 | hTOFEffBC->SetBinContent(bcBin, (trdEntries>0.01 ? tofEntries/trdEntries : 0.0)); | |
2640 | if(trdEntries>0.01 && tofEntries>0.01 && (trdEntries-tofEntries)>=0.01) | |
2641 | hTOFEffBC->SetBinError(bcBin, TMath::Sqrt(tofEntries*(trdEntries-tofEntries)/trdEntries/trdEntries/trdEntries)); | |
2642 | } // end loop over BC bins | |
33d501fa | 2643 | delete hTPCPhiBC; delete hTRDPhiBC; delete hTOFPhiBC; |
2644 | delete projectionBC; | |
2645 | ||
2646 | if(gROOT->FindObject("rangeBC")) delete gROOT->FindObject("rangeBC"); | |
2647 | TH2F* rangeBC = new TH2F("rangeBC", "", 10, -0.5, 3499.5, 10, 0.0, 1.4); | |
2648 | rangeBC->SetStats(kFALSE); | |
2649 | SetStyle(rangeBC->GetXaxis(), "Bunch crossing", 0.07, 0.8, kTRUE, 0.05); | |
2650 | SetStyle(rangeBC->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05); | |
2651 | rangeBC->Draw(); | |
7698e7a4 | 2652 | |
2653 | TLegend* legBC=new TLegend(0.8, 0.7, 0.95, 0.89); | |
2654 | legBC->SetBorderSize(0); | |
2655 | legBC->SetMargin(0.15); | |
2656 | legBC->SetFillColor(0); | |
2657 | if(hTRDEffBC) { | |
2658 | hTRDEffBC->SetStats(kFALSE); | |
4114abc1 | 2659 | SetStyle(hTRDEffBC, 1, kRed, 2, 24, kRed, 1); legBC->AddEntry(hTRDEffBC, "TPC-TRD", "p"); |
2660 | SetStyle(hTOFEffBC, 1, kBlue, 2, 24, kBlue, 1); legBC->AddEntry(hTOFEffBC, "TRD-TOF", "p"); | |
33d501fa | 2661 | hTRDEffBC->Draw("same"); |
7698e7a4 | 2662 | hTOFEffBC->Draw("same"); |
2663 | legBC->Draw(); | |
33d501fa | 2664 | lat->DrawLatex(200., 1.42, "Matching efficiency at 1<p_{T}<3 GeV/c"); |
7698e7a4 | 2665 | } |
2666 | ||
2667 | // reset the user range on the event multiplicity | |
2668 | fCfContainer->SetRangeUser(kEventMult, 0.0, 6.0, kTRUE); | |
33d501fa | 2669 | if(cutTOFbc) fCfContainer->SetRangeUser(kTrackTOFBC, -1000.0, +1000.0); // reset the cut on TOFbc |
2670 | ||
2671 | delete funcConst; | |
7698e7a4 | 2672 | } |
2673 | ||
2bf6d80c | 2674 | |
7698e7a4 | 2675 | //_________________________________________________________________ |
33d501fa | 2676 | void AliTRDcheckESD::PlotPidSummaryFromCF(Int_t centralityClass, Double_t* trendValues, Bool_t useIsolatedBC, Bool_t cutTOFbc) { |
7698e7a4 | 2677 | |
33d501fa | 2678 | if(!fCfContainer) return; |
2679 | ||
7698e7a4 | 2680 | TLatex *lat=new TLatex(); |
2681 | lat->SetTextSize(0.07); | |
2682 | lat->SetTextColor(2); | |
2bf6d80c | 2683 | gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001); |
2684 | gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001); | |
2685 | gPad->Divide(3,3,0.,0.); | |
2686 | TList* l=gPad->GetListOfPrimitives(); | |
7698e7a4 | 2687 | |
33d501fa | 2688 | fCfContainer->SetRangeUser(kTrackDCAxy, -0.999, +0.999); |
2689 | fCfContainer->SetRangeUser(kTrackDCAz, -3.0, +3.0); | |
2690 | if(cutTOFbc) fCfContainer->SetRangeUser(kTrackTOFBC, 0.0, 0.0); | |
2691 | ||
2692 | // find all the isolated bunch crossings with entries | |
2693 | Bool_t isIsolated[3500]; | |
2694 | TH1D* tempTH1D = (TH1D*)fCfContainer->Project(0, kEventBC); | |
2695 | FindIsolatedBCs(tempTH1D, isIsolated); delete tempTH1D; | |
2696 | Int_t nIsolatedBC = 0; | |
2697 | for(Int_t ibc=0; ibc<3500; ++ibc) | |
2698 | if(isIsolated[ibc]) nIsolatedBC++; | |
2699 | ||
7698e7a4 | 2700 | if(centralityClass>0) // select the multiplicity class |
2701 | fCfContainer->SetRangeUser(kEventMult, Double_t(centralityClass), Double_t(centralityClass), kTRUE); | |
2702 | ||
33d501fa | 2703 | if(gROOT->FindObject("rangeEtaPhi2")) delete gROOT->FindObject("rangeEtaPhi2"); |
2704 | TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi2", "", 10, -0.99, +0.99, 10, -3.4, +3.4); | |
2705 | SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05); | |
2706 | SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05); | |
2707 | rangeEtaPhi->SetStats(kFALSE); | |
2708 | ||
7698e7a4 | 2709 | // eta-phi distr. for <Qtot> in layer 0 |
2710 | TVirtualPad* pad; | |
2711 | TProfile2D* hProf2D; | |
2712 | for(Int_t iLayer=0; iLayer<6; ++iLayer) { | |
2713 | pad = ((TVirtualPad*)l->At((iLayer<3 ? iLayer*3 : (iLayer-3)*3+1))); pad->cd(); | |
2714 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
2715 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
2716 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 2717 | rangeEtaPhi->Draw(); |
7698e7a4 | 2718 | |
33d501fa | 2719 | TH3D* hQtotEtaPhi=0x0; |
2720 | if(useIsolatedBC) { | |
2721 | for(Int_t ibc=0; ibc<3500; ++ibc) { | |
2722 | if(!isIsolated[ibc]) continue; | |
2723 | fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc)); | |
2724 | TH3D* temp = (TH3D*)fCfContainer->Project(1, kTrackPhi, kTrackEta, kTrackQtot+iLayer); | |
2725 | if(!hQtotEtaPhi) hQtotEtaPhi = temp; | |
2726 | else {hQtotEtaPhi->Add(temp); delete temp;} | |
2727 | } | |
2728 | fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0); | |
2729 | } | |
2730 | else hQtotEtaPhi = (TH3D*)fCfContainer->Project(1, kTrackPhi, kTrackEta, kTrackQtot+iLayer); | |
2731 | hProf2D = (hQtotEtaPhi ? hQtotEtaPhi->Project3DProfile() : 0x0); | |
2732 | if(hQtotEtaPhi) delete hQtotEtaPhi; | |
7698e7a4 | 2733 | |
33d501fa | 2734 | if(hProf2D) { |
2735 | hProf2D->SetStats(kFALSE); | |
2736 | hProf2D->SetMinimum(0.); | |
2737 | hProf2D->SetMaximum(4.); | |
2738 | hProf2D->Draw("samecolz"); | |
2739 | } | |
7698e7a4 | 2740 | lat->DrawLatex(-0.9, 3.6, Form("TRD <Q_{tot}> Layer %d", iLayer)); |
2741 | DrawTRDGrid(); | |
2742 | } | |
2743 | ||
2744 | // PH versus slice number | |
2745 | pad = ((TVirtualPad*)l->At(2)); pad->cd(); | |
2746 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
2747 | pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15); | |
2748 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 2749 | |
2750 | if(gROOT->FindObject("rangePHslice")) delete gROOT->FindObject("rangePHslice"); | |
2751 | TH2F* rangePHslice=new TH2F("rangePHslice", "", 8, -0.5, 7.5, 10, 0.0, 2000.); | |
2752 | rangePHslice->SetStats(kFALSE); | |
2753 | SetStyle(rangePHslice->GetXaxis(), "slice", 0.07, 0.8, kTRUE, 0.05); | |
2754 | SetStyle(rangePHslice->GetYaxis(), "PH", 0.07, 0.8, kTRUE, 0.05); | |
2755 | rangePHslice->Draw(); | |
2756 | ||
2757 | TF1* funcPol1 = new TF1("funcPol1", "[0]+[1]*x", 2.9, 6.4); | |
2758 | ||
7698e7a4 | 2759 | TH2F* h2F; |
2760 | TH1D* hF; | |
2761 | if((h2F = dynamic_cast<TH2F*>(fHistos->At(kPHSlice+centralityClass)))) { | |
2762 | hF = Proj2D(h2F); | |
2763 | h2F->SetStats(kFALSE); | |
33d501fa | 2764 | h2F->Draw("samecolz"); |
2765 | if(trendValues) { | |
2766 | hF->Fit(funcPol1, "QME0", "goff", 2.9, 6.4); | |
2767 | trendValues[12] = funcPol1->GetParameter(0); // PH plateau | |
2768 | trendValues[13] = funcPol1->GetParError(0); // PH plateau | |
2769 | trendValues[14] = funcPol1->GetParameter(1); // PH slope | |
2770 | trendValues[15] = funcPol1->GetParError(1); // PH slope | |
2771 | } | |
7698e7a4 | 2772 | hF->SetLineWidth(2); |
2773 | hF->SetLineStyle(2); | |
2774 | hF->Draw("same"); | |
2775 | } | |
33d501fa | 2776 | delete funcPol1; |
2777 | ||
7698e7a4 | 2778 | // Qtot vs P |
2779 | pad = ((TVirtualPad*)l->At(5)); pad->cd(); | |
2780 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
2781 | pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15); | |
2782 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
2783 | pad->SetLogz(); | |
7698e7a4 | 2784 | |
33d501fa | 2785 | if(gROOT->FindObject("rangeQtotP")) delete gROOT->FindObject("rangeQtotP"); |
2786 | TH2F* rangeQtotP = new TH2F("rangeQtotP", "", 10, 0.0, 11.99, 10, 0.0, 11.99); | |
2787 | SetStyle(rangeQtotP->GetXaxis(), "P [GeV/c]", 0.07, 0.8, kTRUE, 0.05); | |
2788 | SetStyle(rangeQtotP->GetYaxis(), "Q_{tot}", 0.07, 0.8, kTRUE, 0.05); | |
2789 | rangeQtotP->SetStats(kFALSE); | |
2790 | rangeQtotP->Draw(); | |
2791 | ||
2792 | TH2D* hQtotP_IsolatedBC = 0x0; | |
2793 | for(Int_t ibc=0; ibc<3500; ++ibc) { | |
2794 | if(!isIsolated[ibc]) continue; | |
2795 | fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc)); | |
2796 | TH2D* temp = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackQtot); | |
2797 | if(!hQtotP_IsolatedBC) hQtotP_IsolatedBC = temp; | |
2798 | else {hQtotP_IsolatedBC->Add(temp); delete temp;} | |
2799 | for(Int_t il=1; il<6; ++il) { | |
2800 | temp = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackQtot+il); | |
2801 | hQtotP_IsolatedBC->Add(temp); delete temp; | |
2802 | } | |
2803 | } | |
2804 | fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0); | |
2805 | ||
2806 | TH2D* temp = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackQtot); | |
2807 | TH2D* hQtotP = temp; | |
2808 | for(Int_t il=1; il<6; ++il) { | |
2809 | temp = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackQtot+il); | |
2810 | hQtotP->Add(temp); delete temp; | |
2811 | } | |
2812 | ||
2813 | if(hQtotP_IsolatedBC) | |
2814 | for(Int_t i=1; i<=hQtotP_IsolatedBC->GetXaxis()->GetNbins(); ++i) | |
2815 | hQtotP_IsolatedBC->SetBinContent(i, 1, 0.0); | |
2816 | TH1D* hQtotProj_IsolatedBC = (hQtotP_IsolatedBC ? Proj2D(hQtotP_IsolatedBC) : 0x0); | |
2817 | if(hQtotProj_IsolatedBC) SetStyle(hQtotProj_IsolatedBC, 2, kBlue, 2, 1, kBlue, 1); | |
2818 | if(trendValues && hQtotProj_IsolatedBC && hQtotProj_IsolatedBC->GetEntries()>2) { | |
2819 | trendValues[30] = hQtotProj_IsolatedBC->GetBinContent(hQtotProj_IsolatedBC->FindBin(1.0)); // Landau MPV at 1GeV/c | |
2820 | trendValues[31] = hQtotProj_IsolatedBC->GetBinError(hQtotProj_IsolatedBC->FindBin(1.0)); // Landau width at 1 GeV/c | |
2821 | } | |
2822 | if(hQtotP) | |
2823 | for(Int_t i=1; i<=hQtotP->GetXaxis()->GetNbins(); ++i) | |
2824 | hQtotP->SetBinContent(i, 1, 0.0); | |
2825 | TH1D* hQtotProj = (hQtotP ? Proj2D(hQtotP) : 0x0); | |
2826 | if(hQtotProj) SetStyle(hQtotProj, 2, kBlue, 2, 1, kBlue, 1); | |
2827 | if(trendValues && hQtotProj && hQtotProj->GetEntries()>2) { | |
2828 | trendValues[16] = hQtotProj->GetBinContent(hQtotProj->FindBin(1.0)); // Landau MPV at 1GeV/c | |
2829 | trendValues[17] = hQtotProj->GetBinError(hQtotProj->FindBin(1.0)); // Landau width at 1 GeV/c | |
2830 | } | |
2831 | if(useIsolatedBC && hQtotP_IsolatedBC) { | |
2832 | hQtotP_IsolatedBC->SetStats(kFALSE); | |
2833 | for(Int_t i=1; i<=hQtotP_IsolatedBC->GetXaxis()->GetNbins(); ++i) hQtotP_IsolatedBC->SetBinContent(i, 1, 0.0); | |
2834 | hQtotP_IsolatedBC->Draw("samecolz"); | |
2835 | hQtotProj_IsolatedBC->Draw("same"); | |
2836 | } | |
2837 | if(!useIsolatedBC && hQtotP) { | |
7698e7a4 | 2838 | hQtotP->SetStats(kFALSE); |
33d501fa | 2839 | hQtotP->Draw("samecolz"); |
7698e7a4 | 2840 | hQtotProj->Draw("same"); |
2841 | } | |
2842 | ||
7698e7a4 | 2843 | // reset the user range on the event multiplicity |
2844 | fCfContainer->SetRangeUser(kEventMult, 0.0, 6.0, kTRUE); | |
33d501fa | 2845 | if(cutTOFbc) fCfContainer->SetRangeUser(kTrackTOFBC, -1000.0, +1000.0); // reset the cut on TOFbc |
7698e7a4 | 2846 | } |
2847 | ||
2848 | ||
2849 | //_________________________________________________________________ | |
33d501fa | 2850 | Bool_t AliTRDcheckESD::PlotCentSummary(Double_t* trendValues) { |
7698e7a4 | 2851 | |
33d501fa | 2852 | Bool_t isGoodForSaving=kFALSE; |
2853 | ||
7698e7a4 | 2854 | TLatex* lat=new TLatex(); |
2855 | lat->SetTextSize(0.06); | |
2856 | lat->SetTextColor(2); | |
2857 | ||
33d501fa | 2858 | gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001); |
2859 | gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001); | |
7698e7a4 | 2860 | gPad->Divide(3,3,0.,0.); |
2861 | TList* l=gPad->GetListOfPrimitives(); | |
33d501fa | 2862 | |
2863 | TPad* pad=0x0; | |
2bf6d80c | 2864 | |
33d501fa | 2865 | if(gROOT->FindObject("rangeEffPt")) delete gROOT->FindObject("rangeEffPt"); |
2866 | TH2F* rangeEffPt=new TH2F("rangeEffPt", "",10,0.,10.,10,0.,1.4); | |
2867 | rangeEffPt->SetStats(kFALSE); | |
2868 | SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05); | |
2869 | SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05); | |
2870 | ||
6475ec36 | 2871 | TH3F *h3(NULL), *h3p(NULL), *h3n(NULL); |
2bf6d80c | 2872 | Int_t padsForEffs[5] = {0,3,6,1,4}; |
2873 | for(Int_t iCent=1; iCent<6; ++iCent) { | |
2874 | // TPC-TRD matching efficiencies | |
33d501fa | 2875 | pad = ((TPad*)l->At(padsForEffs[iCent-1])); pad->cd(); |
2876 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
2bf6d80c | 2877 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); |
7698e7a4 | 2878 | |
6475ec36 | 2879 | if(!(h3p = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+iCent)))) continue; |
2880 | if(!(h3n = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+iCent)))) continue; | |
2881 | // ============================================= | |
2882 | if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos+iCent)))) continue; | |
2883 | TH1F* hFeffP = EfficiencyTRD(h3p, h3, kTRUE); | |
2884 | // | |
2885 | if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg+iCent)))) continue; | |
2886 | TH1F* hFeffN = EfficiencyTRD(h3n, h3, kTRUE); | |
2887 | // ============================================= | |
2888 | if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos4+iCent)))) continue; | |
2889 | TH1F* hFeffP4 = EfficiencyTRD(h3p, h3, kTRUE); | |
2890 | // | |
2891 | if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg4+iCent)))) continue; | |
2892 | TH1F* hFeffN4 = EfficiencyTRD(h3n, h3, kTRUE); | |
2893 | // ============================================= | |
2894 | if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos5+iCent)))) continue; | |
2895 | TH1F* hFeffP5 = EfficiencyTRD(h3p, h3, kTRUE); | |
2896 | // | |
2897 | if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg5+iCent)))) continue; | |
2898 | TH1F* hFeffN5 = EfficiencyTRD(h3n, h3, kTRUE); | |
2899 | // ============================================= | |
2900 | if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos6+iCent)))) continue; | |
2901 | TH1F* hFeffP6 = EfficiencyTRD(h3p, h3, kTRUE); | |
2902 | // | |
2903 | if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg6+iCent)))) continue; | |
2904 | TH1F* hFeffN6 = EfficiencyTRD(h3n, h3, kTRUE); | |
2bf6d80c | 2905 | |
33d501fa | 2906 | rangeEffPt->Draw(); |
2907 | ||
2bf6d80c | 2908 | TLine line; |
2909 | line.SetLineStyle(2); | |
2910 | line.SetLineWidth(2); | |
33d501fa | 2911 | line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7); |
2912 | line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9); | |
2bf6d80c | 2913 | line.SetLineStyle(1); |
2914 | line.SetLineWidth(1); | |
33d501fa | 2915 | line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 1.0, rangeEffPt->GetXaxis()->GetXmax(), 1.0); |
2916 | if(hFeffP) SetStyle(hFeffP, 1, kRed, 1, 24, kRed, 1); | |
2917 | if(hFeffP4) SetStyle(hFeffP4, 1, kRed, 1, 25, kRed, 1); | |
2918 | if(hFeffP5) SetStyle(hFeffP5, 1, kRed, 1, 26, kRed, 1); | |
2919 | if(hFeffP6) SetStyle(hFeffP6, 1, kRed, 1, 27, kRed, 1); | |
2920 | if(hFeffN) SetStyle(hFeffN, 1, kBlue, 1, 24, kBlue, 1); | |
2921 | if(hFeffN4) SetStyle(hFeffN4, 1, kBlue, 1, 25, kBlue, 1); | |
2922 | if(hFeffN5) SetStyle(hFeffN5, 1, kBlue, 1, 26, kBlue, 1); | |
2923 | if(hFeffN6) SetStyle(hFeffN6, 1, kBlue, 1, 27, kBlue, 1); | |
2bf6d80c | 2924 | |
33d501fa | 2925 | TLegend* leg=new TLegend(0.16, 0.7, 0.61, 0.89); |
2bf6d80c | 2926 | leg->SetFillColor(0); |
33d501fa | 2927 | leg->SetNColumns(2); |
2928 | leg->SetTextSize(0.039); | |
2929 | leg->SetMargin(0.1); | |
2930 | if(hFeffP && hFeffP->Integral()>0.001) { | |
2931 | isGoodForSaving = kTRUE; | |
2932 | hFeffP->Draw("same"); | |
2933 | leg->AddEntry(hFeffP, "pos. (#geq 1 trcklt)", "p"); | |
2934 | } | |
2935 | if(hFeffN && hFeffN->Integral()>0.001) { | |
2936 | isGoodForSaving = kTRUE; | |
2937 | hFeffN->Draw("same"); | |
2938 | leg->AddEntry(hFeffN, "neg. (#geq 1 trcklt)", "p"); | |
2939 | } | |
2940 | if(hFeffP4 && hFeffP4->Integral()>0.001) { | |
2941 | isGoodForSaving = kTRUE; | |
2942 | hFeffP4->Draw("same"); | |
2943 | leg->AddEntry(hFeffP4, "pos. (4 trcklts)", "p"); | |
2944 | } | |
2945 | if(hFeffN4 && hFeffN4->Integral()>0.001) { | |
2946 | isGoodForSaving = kTRUE; | |
2947 | hFeffN4->Draw("same"); | |
2948 | leg->AddEntry(hFeffN4, "neg. (4 trcklts)", "p"); | |
2949 | } | |
2950 | if(hFeffP5 && hFeffP5->Integral()>0.001) { | |
2951 | isGoodForSaving = kTRUE; | |
2952 | hFeffP5->Draw("same"); | |
2953 | leg->AddEntry(hFeffP5, "pos. (5 trcklts)", "p"); | |
2954 | } | |
2955 | if(hFeffN5 && hFeffN5->Integral()>0.001) { | |
2956 | isGoodForSaving = kTRUE; | |
2957 | hFeffN5->Draw("same"); | |
2958 | leg->AddEntry(hFeffN5, "neg. (5 trcklts)", "p"); | |
2959 | } | |
2960 | if(hFeffP6 && hFeffP6->Integral()>0.001) { | |
2961 | isGoodForSaving = kTRUE; | |
2962 | hFeffP6->Draw("same"); | |
2963 | leg->AddEntry(hFeffP6, "pos. (6 trcklts)", "p"); | |
2964 | } | |
2965 | if(hFeffN6 && hFeffN6->Integral()>0.001) { | |
2966 | isGoodForSaving = kTRUE; | |
2967 | hFeffN6->Draw("same"); | |
2968 | leg->AddEntry(hFeffN6, "neg. (6 trklts)", "p"); | |
2969 | } | |
2bf6d80c | 2970 | |
33d501fa | 2971 | if(isGoodForSaving) { |
2972 | if(iCent==1) leg->Draw(); | |
2973 | lat->DrawLatex(5.6, 1.3, Form("Centrality class %d", iCent)); | |
2974 | lat->DrawLatex(0.5, 1.42, "TPC-TRD matching efficiency"); | |
2975 | } | |
2976 | } // end loop over multiplicity intervals | |
2bf6d80c | 2977 | |
33d501fa | 2978 | // Number of clusters per TRD track |
2979 | pad = ((TPad*)l->At(2)); pad->cd(); | |
2bf6d80c | 2980 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); |
2981 | pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15); | |
2982 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 2983 | if(gROOT->FindObject("rangeNcls")) delete gROOT->FindObject("rangeNcls"); |
2984 | TH2F* rangeNcls = new TH2F("rangeNcls", "", 10, 0.0, 199.9, 10, 0.0, 1.199); | |
2985 | SetStyle(rangeNcls->GetXaxis(), "# TRD clusters", 0.07, 0.8, kTRUE, 0.05); | |
2986 | SetStyle(rangeNcls->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05); | |
2987 | rangeNcls->SetStats(kFALSE); | |
2988 | rangeNcls->Draw(); | |
2989 | ||
2bf6d80c | 2990 | TH2F* h2F[6]; TH1D* proj[6]; |
2991 | TLegend* leg=new TLegend(0.2, 0.7, 0.5, 0.95); | |
2992 | leg->SetFillColor(0); | |
33d501fa | 2993 | Bool_t isGood=kFALSE; |
2bf6d80c | 2994 | for(Int_t iCent=0; iCent<6; ++iCent) { |
2995 | h2F[iCent] = dynamic_cast<TH2F*>(fHistos->At(kNClsTrackTRD+iCent)); | |
33d501fa | 2996 | proj[iCent] = (h2F[iCent] && h2F[iCent]->GetEntries()>10 ? h2F[iCent]->ProjectionY(Form("projCent%d",iCent)) : 0x0); |
2997 | if(proj[iCent]) { | |
2998 | proj[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2); | |
2999 | Double_t maximum = proj[iCent]->GetMaximum(); | |
3000 | if(maximum>1.0) | |
3001 | proj[iCent]->Scale(1.0/maximum); | |
3002 | proj[iCent]->SetStats(kFALSE); | |
3003 | proj[iCent]->Draw("same"); | |
3004 | leg->AddEntry(proj[iCent], (iCent==0 ? "all centralities" : Form("centrality class %d", iCent)), "l"); | |
3005 | isGood = kTRUE; | |
3006 | } | |
2bf6d80c | 3007 | } |
33d501fa | 3008 | if(isGood) leg->Draw(); |
3009 | isGoodForSaving = isGoodForSaving || isGood; | |
3010 | ||
2bf6d80c | 3011 | // Qtot vs P |
33d501fa | 3012 | pad = ((TPad*)l->At(5)); pad->cd(); |
2bf6d80c | 3013 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); |
3014 | pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15); | |
3015 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 3016 | if(gROOT->FindObject("rangeQtot")) delete gROOT->FindObject("rangeQtot"); |
3017 | TH2F* rangeQtot = new TH2F("rangeQtot", "", 10, 0.0, 9.999, 10, 0.0, 1.199); | |
3018 | SetStyle(rangeQtot->GetXaxis(), "Q_{tot} (a.u.)", 0.07, 0.8, kTRUE, 0.05); | |
3019 | SetStyle(rangeQtot->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05); | |
3020 | rangeQtot->SetStats(kFALSE); | |
3021 | rangeQtot->Draw(); | |
3022 | ||
2bf6d80c | 3023 | TH1D* projQ[6]; |
3024 | TLegend* leg2=new TLegend(0.6, 0.7, 0.9, 0.95); | |
3025 | leg2->SetFillColor(0); | |
33d501fa | 3026 | isGood = kFALSE; |
2bf6d80c | 3027 | for(Int_t iCent=0; iCent<6; ++iCent) { |
3028 | h2F[iCent] = dynamic_cast<TH2F*>(fHistos->At(kQtotP+iCent)); | |
33d501fa | 3029 | projQ[iCent] = (h2F[iCent] && h2F[iCent]->GetEntries()>10 ? h2F[iCent]->ProjectionY(Form("projQCent%d",iCent)) : 0x0); |
3030 | if(projQ[iCent]) { | |
3031 | projQ[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2); | |
3032 | Double_t maximum = projQ[iCent]->GetMaximum(); | |
3033 | if(maximum>1.0) | |
3034 | projQ[iCent]->Scale(1.0/maximum); | |
3035 | projQ[iCent]->SetStats(kFALSE); | |
3036 | projQ[iCent]->Draw("same"); | |
3037 | leg2->AddEntry(projQ[iCent], (iCent==0 ? "all centralities" : Form("centrality class %d", iCent)), "l"); | |
3038 | isGood = kTRUE; | |
3039 | } | |
2bf6d80c | 3040 | } |
33d501fa | 3041 | if(isGood) leg2->Draw(); |
3042 | isGoodForSaving = isGoodForSaving || isGood; | |
3043 | return isGoodForSaving; | |
2bf6d80c | 3044 | } |
3045 | ||
3046 | ||
3047 | //_________________________________________________________________ | |
33d501fa | 3048 | Bool_t AliTRDcheckESD::PlotTrackingSummary(Int_t centralityClass, Double_t* trendValues) { |
2bf6d80c | 3049 | |
33d501fa | 3050 | Bool_t isGoodForSaving=kFALSE; |
3051 | ||
2bf6d80c | 3052 | TLatex *lat=new TLatex(); |
3053 | lat->SetTextSize(0.07); | |
3054 | lat->SetTextColor(2); | |
3055 | gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001); | |
3056 | gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001); | |
3057 | gPad->Divide(3,3,0.,0.); | |
3058 | TList* l=gPad->GetListOfPrimitives(); | |
3059 | // eta-phi distr. for positive TPC tracks | |
3060 | TVirtualPad* pad = ((TVirtualPad*)l->At(0)); pad->cd(); | |
3061 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
3062 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
3063 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 3064 | if(gROOT->FindObject("rangeEtaPhi")) delete gROOT->FindObject("rangeEtaPhi"); |
3065 | TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi", "", 10, -0.99, +0.99, 10, -3.4, +3.4); | |
3066 | SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05); | |
3067 | SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05); | |
3068 | rangeEtaPhi->SetStats(kFALSE); | |
3069 | rangeEtaPhi->Draw(); | |
3070 | lat->DrawLatex(-0.9, 3.6, "TPC positive ref. tracks"); | |
3071 | ||
2bf6d80c | 3072 | TH3F* h3F = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)); |
33d501fa | 3073 | TH2F* h2FtpcP = 0x0; |
2bf6d80c | 3074 | Float_t nada=0.0; |
33d501fa | 3075 | if(h3F && h3F->GetEntries()>10) { |
3076 | h2FtpcP = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone(); | |
3077 | h2FtpcP->SetStats(kFALSE); | |
3078 | h2FtpcP->Draw("samecolz"); isGoodForSaving = kTRUE; | |
3079 | isGoodForSaving = kTRUE; | |
3080 | } | |
2bf6d80c | 3081 | //----------------- |
3082 | // eta-phi distr. for negative TPC tracks | |
3083 | pad = ((TVirtualPad*)l->At(1)); pad->cd(); | |
3084 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
3085 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
3086 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 3087 | rangeEtaPhi->Draw(); |
2bf6d80c | 3088 | lat->DrawLatex(-0.9, 3.6, "TPC negative ref. tracks"); |
33d501fa | 3089 | |
3090 | h3F = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)); | |
3091 | TH2F* h2FtpcN = 0x0; | |
3092 | if(h3F && h3F->GetEntries()>10) { | |
3093 | h2FtpcN = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone(); | |
3094 | h2FtpcN->SetStats(kFALSE); | |
3095 | h2FtpcN->Draw("samecolz"); | |
3096 | isGoodForSaving = kTRUE; | |
3097 | } | |
2bf6d80c | 3098 | //---------------------------------------------- |
3099 | // eta-phi distr. for positive TRD tracks | |
3100 | pad = ((TVirtualPad*)l->At(3)); pad->cd(); | |
3101 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
3102 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
3103 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 3104 | rangeEtaPhi->Draw(); |
2bf6d80c | 3105 | lat->DrawLatex(-0.9, 3.6, "TRD positive ref. tracks"); |
33d501fa | 3106 | |
3107 | h3F = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos+centralityClass)); | |
3108 | TH2F* h2FtrdP = 0x0; | |
3109 | if(h3F && h3F->GetEntries()>10) { | |
3110 | h2FtrdP = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone(); | |
3111 | h2FtrdP->SetStats(kFALSE); | |
3112 | h2FtrdP->SetMaximum((h2FtpcP ? h2FtpcP->GetMaximum() : h2FtrdP->GetMaximum())); | |
3113 | h2FtrdP->Draw("samecolz"); | |
3114 | isGoodForSaving=kTRUE; | |
3115 | } | |
2bf6d80c | 3116 | //-------------------------------------------- |
3117 | // eta-phi distr. for negative TRD tracks | |
3118 | pad = ((TVirtualPad*)l->At(4)); pad->cd(); | |
3119 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
3120 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
3121 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 3122 | rangeEtaPhi->Draw(); |
2bf6d80c | 3123 | lat->DrawLatex(-0.9, 3.6, "TRD negative ref. tracks"); |
33d501fa | 3124 | |
3125 | h3F = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg+centralityClass)); | |
3126 | TH2F* h2FtrdN = 0x0; | |
3127 | if(h3F && h3F->GetEntries()>10) { | |
3128 | h2FtrdN = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone(); | |
3129 | h2FtrdN->SetStats(kFALSE); | |
3130 | h2FtrdN->SetMaximum(h2FtpcN ? h2FtpcN->GetMaximum() : h2FtrdN->GetMaximum()); | |
3131 | h2FtrdN->Draw("samecolz"); | |
3132 | isGoodForSaving=kTRUE; | |
3133 | } | |
2bf6d80c | 3134 | //---------------------------------------------- |
3135 | // eta-phi efficiency for positive TRD tracks | |
3136 | pad = ((TVirtualPad*)l->At(6)); pad->cd(); | |
3137 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
3138 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
3139 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 3140 | rangeEtaPhi->Draw(); |
2bf6d80c | 3141 | lat->DrawLatex(-0.9, 3.6, "Efficiency positive tracks"); |
33d501fa | 3142 | |
3143 | TH2F* h2Feff = (h2FtrdP ? (TH2F*)h2FtrdP->Clone("h2FeffPos") : 0x0); | |
3144 | if(h2Feff) { | |
3145 | h2Feff->Reset(); | |
3146 | h2Feff->SetStats(kFALSE); | |
3147 | h2Feff->Divide(h2FtrdP, h2FtpcP); | |
3148 | h2Feff->SetMaximum(1.0); | |
3149 | if(h2Feff->GetEntries()>1) { h2Feff->Draw("samecolz"); isGoodForSaving=kTRUE; } | |
3150 | } | |
2bf6d80c | 3151 | //------------------------------------------------- |
3152 | // eta-phi efficiency for negative TRD tracks | |
3153 | pad = ((TVirtualPad*)l->At(7)); pad->cd(); | |
3154 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
3155 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
3156 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 3157 | rangeEtaPhi->Draw(); |
2bf6d80c | 3158 | lat->DrawLatex(-0.9, 3.6, "Efficiency negative tracks"); |
33d501fa | 3159 | |
3160 | h2Feff = (h2FtrdN ? (TH2F*)h2FtrdN->Clone("h2FeffNeg") : 0x0); | |
3161 | if(h2Feff) { | |
3162 | h2Feff->Reset(); | |
3163 | h2Feff->SetStats(kFALSE); | |
3164 | h2Feff->Divide(h2FtrdN, h2FtpcN); | |
3165 | h2Feff->SetMaximum(1.0); | |
3166 | if(h2Feff->GetEntries()>0.1) { h2Feff->Draw("samecolz"); isGoodForSaving=kTRUE; } | |
3167 | } | |
2bf6d80c | 3168 | //----------------------------------------------------- |
3169 | // <ntracklets> vs (phi,eta) | |
3170 | pad = ((TVirtualPad*)l->At(2)); pad->cd(); | |
3171 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
3172 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
3173 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 3174 | rangeEtaPhi->Draw(); |
3175 | lat->DrawLatex(-0.9, 3.6, "TRD <N_{tracklets}>"); | |
3176 | ||
2bf6d80c | 3177 | TProfile2D* hProf2D; |
3178 | if((hProf2D = dynamic_cast<TProfile2D*>(fHistos->At(kTRDEtaPhiAvNtrkl+centralityClass)))) { | |
33d501fa | 3179 | if(hProf2D->GetEntries()>10) { |
3180 | hProf2D->SetStats(kFALSE); | |
3181 | hProf2D->SetMinimum(0.); | |
3182 | hProf2D->SetMaximum(6.); | |
3183 | if(hProf2D->GetEntries()>1) { hProf2D->Draw("samecolz"); isGoodForSaving = kTRUE; } | |
3184 | } | |
2bf6d80c | 3185 | } |
3186 | //--------------------------------------------------------- | |
3187 | // TPC-TRD matching efficiency vs pt | |
3188 | pad = ((TVirtualPad*)l->At(5)); pad->cd(); | |
3189 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); | |
33d501fa | 3190 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); |
2bf6d80c | 3191 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); |
3192 | TH1F* hFeffP = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)), | |
3fb80f44 | 3193 | dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos+centralityClass)), kTRUE); |
2bf6d80c | 3194 | TH1F* hFeffN = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)), |
3fb80f44 | 3195 | dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg+centralityClass)), kTRUE); |
2bf6d80c | 3196 | TH1F* hFeffP4 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)), |
3fb80f44 | 3197 | dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos4+centralityClass)), kTRUE); |
2bf6d80c | 3198 | TH1F* hFeffN4 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)), |
3fb80f44 | 3199 | dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg4+centralityClass)), kTRUE); |
2bf6d80c | 3200 | TH1F* hFeffP5 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)), |
3fb80f44 | 3201 | dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos5+centralityClass)), kTRUE); |
2bf6d80c | 3202 | TH1F* hFeffN5 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)), |
3fb80f44 | 3203 | dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg5+centralityClass)), kTRUE); |
2bf6d80c | 3204 | TH1F* hFeffP6 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)), |
3fb80f44 | 3205 | dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos6+centralityClass)), kTRUE); |
2bf6d80c | 3206 | TH1F* hFeffN6 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)), |
3fb80f44 | 3207 | dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg6+centralityClass)), kTRUE); |
2bf6d80c | 3208 | |
33d501fa | 3209 | TF1* funcConst = new TF1("funcConst", "[0]", 1.0, 3.0); |
3210 | ||
3211 | if(gROOT->FindObject("rangeEffPt2")) delete gROOT->FindObject("rangeEffPt2"); | |
3212 | TH2F* rangeEffPt2=new TH2F("rangeEffPt2", "",10,0.,10.,10,0.,1.4); | |
3213 | rangeEffPt2->SetStats(kFALSE); | |
3214 | SetStyle(rangeEffPt2->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05); | |
3215 | SetStyle(rangeEffPt2->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05); | |
3216 | rangeEffPt2->Draw(); | |
3217 | lat->DrawLatex(0.5, 1.42, "TRD-TPC matching efficiency"); | |
3fb80f44 | 3218 | //++++++++++++++++++ |
2bf6d80c | 3219 | TLine line; |
3220 | line.SetLineStyle(2); | |
3221 | line.SetLineWidth(2); | |
33d501fa | 3222 | line.DrawLine(rangeEffPt2->GetXaxis()->GetXmin(), 0.7, rangeEffPt2->GetXaxis()->GetXmax(), 0.7); |
3223 | line.DrawLine(rangeEffPt2->GetXaxis()->GetXmin(), 0.9, rangeEffPt2->GetXaxis()->GetXmax(), 0.9); | |
2bf6d80c | 3224 | line.SetLineStyle(1); |
3225 | line.SetLineWidth(1); | |
33d501fa | 3226 | line.DrawLine(rangeEffPt2->GetXaxis()->GetXmin(), 1.0, rangeEffPt2->GetXaxis()->GetXmax(), 1.0); |
3227 | TLegend* leg=new TLegend(0.2, 0.7, 0.6, 0.89); | |
3228 | leg->SetNColumns(2); | |
2bf6d80c | 3229 | leg->SetFillColor(0); |
3fb80f44 | 3230 | if(hFeffP){ |
3231 | hFeffP->SetMarkerStyle(24); | |
3232 | hFeffP->SetMarkerColor(2); | |
3233 | hFeffP->SetLineColor(2); | |
33d501fa | 3234 | if(trendValues && hFeffP->GetEntries()>1) { |
3235 | hFeffP->Fit(funcConst, "QME0", "goff", 1.0, 3.0); | |
3236 | trendValues[0] = funcConst->GetParameter(0); | |
3237 | trendValues[1] = funcConst->GetParError(0); | |
3238 | } | |
3239 | if(hFeffP->Integral()>0.001) { | |
3240 | hFeffP->Draw("same"); | |
3241 | leg->AddEntry(hFeffP, "positives (#geq 1 tracklet)", "p"); | |
3242 | } | |
3fb80f44 | 3243 | } |
3244 | if(hFeffN){ | |
3245 | hFeffN->SetMarkerStyle(24); | |
3246 | hFeffN->SetMarkerColor(4); | |
3247 | hFeffN->SetLineColor(4); | |
33d501fa | 3248 | if(trendValues && hFeffN->GetEntries()>1) { |
3249 | hFeffN->Fit(funcConst, "QME0", "goff", 1.0, 3.0); | |
3250 | trendValues[2] = funcConst->GetParameter(0); | |
3251 | trendValues[3] = funcConst->GetParError(0); | |
3252 | } | |
3253 | if(hFeffN->Integral()>0.001) { | |
3254 | hFeffN->Draw("same"); | |
3255 | leg->AddEntry(hFeffN, "negatives (#geq 1 tracklet)", "p"); | |
3256 | } | |
3257 | } | |
3258 | if(hFeffP4){ | |
3259 | hFeffP4->SetMarkerStyle(25); | |
3260 | hFeffP4->SetMarkerColor(2); | |
3261 | hFeffP4->SetLineColor(2); | |
3262 | if(hFeffP4->Integral()>0.001) { | |
3263 | hFeffP4->Draw("same"); | |
3264 | leg->AddEntry(hFeffP4, "positives (4 tracklets)", "p"); | |
3265 | } | |
3fb80f44 | 3266 | } |
3267 | if(hFeffN4){ | |
3268 | hFeffN4->SetMarkerStyle(25); | |
3269 | hFeffN4->SetMarkerColor(4); | |
3270 | hFeffN4->SetLineColor(4); | |
33d501fa | 3271 | if(hFeffN4->Integral()>0.001) { |
3272 | hFeffN4->Draw("same"); | |
3273 | leg->AddEntry(hFeffN4, "negatives (4 tracklets)", "p"); | |
3274 | } | |
3275 | } | |
3276 | if(hFeffP5){ | |
3277 | hFeffP5->SetMarkerStyle(26); | |
3278 | hFeffP5->SetMarkerColor(2); | |
3279 | hFeffP5->SetLineColor(2); | |
3280 | if(hFeffP5->Integral()>0.001) { | |
3281 | hFeffP5->Draw("same"); | |
3282 | leg->AddEntry(hFeffP5, "positives (5 tracklets)", "p"); | |
3283 | } | |
3fb80f44 | 3284 | } |
3285 | if(hFeffN5){ | |
3286 | hFeffN5->SetMarkerStyle(26); | |
3287 | hFeffN5->SetMarkerColor(4); | |
3288 | hFeffN5->SetLineColor(4); | |
33d501fa | 3289 | if(hFeffN5->Integral()>0.001) { |
3290 | hFeffN5->Draw("same"); | |
3291 | leg->AddEntry(hFeffN5, "negatives (5 tracklets)", "p"); | |
3292 | } | |
3293 | } | |
3294 | if(hFeffP6){ | |
3295 | hFeffP6->SetMarkerStyle(27); | |
3296 | hFeffP6->SetMarkerColor(2); | |
3297 | hFeffP6->SetLineColor(2); | |
3298 | if(hFeffP6->Integral()>0.001) { | |
3299 | hFeffP6->Draw("same"); | |
3300 | leg->AddEntry(hFeffP6, "positives (6 tracklets)", "p"); | |
3301 | } | |
3fb80f44 | 3302 | } |
3303 | if(hFeffN6){ | |
3304 | hFeffN6->SetMarkerStyle(27); | |
3305 | hFeffN6->SetMarkerColor(4); | |
3306 | hFeffN6->SetLineColor(4); | |
33d501fa | 3307 | if(hFeffN6->Integral()>0.001) { |
3308 | hFeffN6->Draw("same"); | |
3309 | leg->AddEntry(hFeffN6, "negatives (6 tracklets)", "p"); | |
3310 | } | |
3fb80f44 | 3311 | } |
2bf6d80c | 3312 | leg->Draw(); |
3313 | ||
3314 | //-------------------------------------------------------------- | |
3315 | // Nclusters per TRD track | |
3316 | pad = ((TVirtualPad*)l->At(8)); pad->cd(); | |
3317 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.12); | |
33d501fa | 3318 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); |
2bf6d80c | 3319 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); |
3320 | pad->SetLogz(); | |
33d501fa | 3321 | if(gROOT->FindObject("rangeNclsP")) delete gROOT->FindObject("rangeNclsP"); |
3322 | TH2F* rangeNclsP = new TH2F("rangeNclsP", "", 10, 0.0, 11.99, 10, 0.0, 199.0); | |
3323 | SetStyle(rangeNclsP->GetXaxis(), "p [GeV/c]", 0.07, 0.8, kTRUE, 0.05); | |
3324 | SetStyle(rangeNclsP->GetYaxis(), "#clusters", 0.07, 0.8, kTRUE, 0.05); | |
3325 | rangeNclsP->SetStats(kFALSE); | |
3326 | rangeNclsP->Draw(); | |
3327 | lat->DrawLatex(1.0, 205., "TRD Clusters / track"); | |
3328 | ||
3329 | TH2F* hNclsVsP=0x0; | |
3330 | if((hNclsVsP = dynamic_cast<TH2F*>(fHistos->At(kNClsTrackTRD+centralityClass)))) { | |
3331 | hNclsVsP->SetStats(kFALSE); | |
3332 | if(hNclsVsP->GetEntries()>10) { | |
3333 | hNclsVsP->Draw("samecolz"); isGoodForSaving=kTRUE; | |
3334 | if(trendValues) { | |
3335 | TProfile* h2FProf = hNclsVsP->ProfileX("nclsVsPprof"); | |
3336 | h2FProf->Fit(funcConst, "QME0", "goff", 1.0, 3.0); | |
3337 | trendValues[4] = funcConst->GetParameter(0); | |
3338 | trendValues[5] = funcConst->GetParError(0); | |
3339 | } | |
3340 | } | |
2bf6d80c | 3341 | } |
33d501fa | 3342 | |
3343 | delete funcConst; | |
3344 | return isGoodForSaving; | |
2bf6d80c | 3345 | } |
3346 | ||
3347 | ||
3348 | //_________________________________________________________________ | |
33d501fa | 3349 | Bool_t AliTRDcheckESD::PlotPidSummary(Int_t centralityClass, Double_t* trendValues) { |
2bf6d80c | 3350 | |
33d501fa | 3351 | Bool_t isGoodForSaving=kFALSE; |
3352 | ||
2bf6d80c | 3353 | TLatex *lat=new TLatex(); |
3354 | lat->SetTextSize(0.07); | |
3355 | lat->SetTextColor(2); | |
3356 | gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001); | |
3357 | gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001); | |
3358 | gPad->Divide(3,3,0.,0.); | |
3359 | TList* l=gPad->GetListOfPrimitives(); | |
3360 | // eta-phi distr. for <Qtot> in layer 0 | |
3361 | TVirtualPad* pad; | |
3362 | TProfile2D* hProf2D; | |
33d501fa | 3363 | if(gROOT->FindObject("rangeEtaPhi2")) delete gROOT->FindObject("rangeEtaPhi2"); |
3364 | TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi2", "", 10, -0.99, +0.99, 10, -3.4, +3.4); | |
3365 | SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05); | |
3366 | SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05); | |
3367 | rangeEtaPhi->SetStats(kFALSE); | |
3368 | ||
2bf6d80c | 3369 | for(Int_t iLayer=0; iLayer<6; ++iLayer) { |
3370 | pad = ((TVirtualPad*)l->At((iLayer<3 ? iLayer*3 : (iLayer-3)*3+1))); pad->cd(); | |
3371 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
3372 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
3373 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 3374 | rangeEtaPhi->Draw(); |
2bf6d80c | 3375 | lat->DrawLatex(-0.9, 3.6, Form("TRD <Q_{tot}> Layer %d", iLayer)); |
33d501fa | 3376 | |
3377 | if(!(hProf2D = dynamic_cast<TProfile2D*>(fHistos->At(kTRDEtaPhiAvQtot+6*centralityClass+iLayer)))) continue; | |
3378 | if(hProf2D && hProf2D->GetEntries()>10) { | |
3379 | hProf2D->SetStats(kFALSE); | |
3380 | hProf2D->SetMinimum(0.); | |
3381 | hProf2D->SetMaximum(4.); | |
3382 | if(hProf2D->GetEntries()>10) { hProf2D->Draw("samecolz"); isGoodForSaving=kTRUE; } | |
3383 | } | |
2bf6d80c | 3384 | } |
3385 | ||
3386 | // PH versus slice number | |
3387 | pad = ((TVirtualPad*)l->At(2)); pad->cd(); | |
3388 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
3389 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
3390 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
33d501fa | 3391 | if(gROOT->FindObject("rangePHslice")) delete gROOT->FindObject("rangePHslice"); |
3392 | TH2F* rangePHslice = new TH2F("rangePHslice", "", 10, -0.5, 7.5, 10, 0.0, 2000.0); | |
3393 | SetStyle(rangePHslice->GetXaxis(), "slice", 0.07, 0.8, kTRUE, 0.05); | |
3394 | SetStyle(rangePHslice->GetYaxis(), "PH", 0.07, 0.8, kTRUE, 0.05); | |
3395 | rangePHslice->SetStats(kFALSE); | |
3396 | rangePHslice->Draw(); | |
3397 | ||
3398 | TF1* funcPol1 = new TF1("funcPol1", "[0]+[1]*x", 2.9, 6.4); | |
3399 | ||
2bf6d80c | 3400 | TH2F* h2F; |
7698e7a4 | 3401 | TH1D* hF; |
2bf6d80c | 3402 | if((h2F = dynamic_cast<TH2F*>(fHistos->At(kPHSlice+centralityClass)))) { |
33d501fa | 3403 | if(h2F && h2F->GetEntries()>10) { |
3404 | hF = Proj2D(h2F); | |
3405 | h2F->SetStats(kFALSE); | |
3406 | h2F->Draw("samecolz"); | |
3407 | isGoodForSaving=kTRUE; | |
3408 | if(trendValues) { | |
3409 | hF->Fit(funcPol1, "QME0", "goff", 2.9, 6.4); | |
3410 | trendValues[6] = funcPol1->GetParameter(0); | |
3411 | trendValues[7] = funcPol1->GetParError(0); | |
3412 | trendValues[8] = funcPol1->GetParameter(1); | |
3413 | trendValues[9] = funcPol1->GetParError(1); | |
3414 | } | |
3415 | hF->SetLineWidth(2); | |
3416 | hF->Draw("same"); | |
3417 | } | |
2bf6d80c | 3418 | } |
33d501fa | 3419 | delete funcPol1; |
2bf6d80c | 3420 | |
3421 | // Qtot vs P | |
3422 | pad = ((TVirtualPad*)l->At(5)); pad->cd(); | |
3423 | pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1); | |
3424 | pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15); | |
3425 | pad->SetGridx(kFALSE); pad->SetGridy(kFALSE); | |
3426 | pad->SetLogz(); | |
33d501fa | 3427 | if(gROOT->FindObject("rangeQtotP")) delete gROOT->FindObject("rangeQtotP"); |
3428 | TH2F* rangeQtotP = new TH2F("rangeQtotP", "", 10, 0.0, 11.99, 10, 0.0, 11.99); | |
3429 | SetStyle(rangeQtotP->GetXaxis(), "P [GeV/c]", 0.07, 0.8, kTRUE, 0.05); | |
3430 | SetStyle(rangeQtotP->GetYaxis(), "Q_{tot}", 0.07, 0.8, kTRUE, 0.05); | |
3431 | rangeQtotP->SetStats(kFALSE); | |
3432 | rangeQtotP->Draw(); | |
3433 | ||
2bf6d80c | 3434 | if((h2F = dynamic_cast<TH2F*>(fHistos->At(kQtotP+centralityClass)))) { |
33d501fa | 3435 | if(h2F && h2F->GetEntries()>10) { |
3436 | h2F->SetStats(kFALSE); | |
3437 | h2F->Draw("samecolz"); | |
3438 | isGoodForSaving=kTRUE; | |
3439 | hF = Proj2D(h2F); | |
3440 | hF->SetLineWidth(2); | |
3441 | hF->Draw("same"); | |
3442 | if(trendValues) { | |
3443 | trendValues[10] = hF->GetBinContent(hF->FindBin(1.0)); | |
3444 | trendValues[11] = hF->GetBinError(hF->FindBin(1.0)); | |
3445 | } | |
2bf6d80c | 3446 | } |
33d501fa | 3447 | } |
3448 | return isGoodForSaving; | |
2bf6d80c | 3449 | } |
7698e7a4 | 3450 | |
7698e7a4 | 3451 | //__________________________________________________________________________________________________ |
3452 | void AliTRDcheckESD::DrawTRDGrid() { | |
3453 | // | |
3454 | // Draw a grid of lines showing the TRD supermodule and stack structure in (eta,phi) coordinates. | |
3455 | // The canvas on which to draw must already exist. | |
3456 | // | |
3457 | TLine line; | |
3458 | line.SetLineColor(2); | |
4114abc1 | 3459 | line.SetLineWidth(1); |
7698e7a4 | 3460 | line.SetLineStyle(2); |
3461 | for(Int_t i=0; i<=9; ++i) { | |
3462 | line.DrawLine(-1.0, 2.0*TMath::Pi()/18.0*i, +1.0, 2.0*TMath::Pi()/18.0*i); | |
3463 | line.DrawLine(-1.0, -2.0*TMath::Pi()/18.0*i, +1.0, -2.0*TMath::Pi()/18.0*i); | |
3464 | } | |
3465 | line.DrawLine(-0.85, -3.2, -0.85, +3.2); | |
3466 | line.DrawLine(-0.54, -3.2, -0.54, +3.2); | |
3467 | line.DrawLine(-0.16, -3.2, -0.16, +3.2); | |
3468 | line.DrawLine(+0.16, -3.2, +0.16, +3.2); | |
3469 | line.DrawLine(+0.54, -3.2, +0.54, +3.2); | |
3470 | line.DrawLine(+0.85, -3.2, +0.85, +3.2); | |
3471 | } | |
3472 | ||
3473 | //_________________________________________________________________ | |
3474 | void AliTRDcheckESD::SetStyle(TH1* hist, | |
33d501fa | 3475 | Int_t lineStyle, Int_t lineColor, Int_t lineWidth, |
4114abc1 | 3476 | Int_t markerStyle, Int_t markerColor, Int_t markerSize) { |
7698e7a4 | 3477 | // |
3478 | // Set style settings for histograms | |
3479 | // | |
3480 | hist->SetLineStyle(lineStyle); | |
3481 | hist->SetLineColor(lineColor); | |
3482 | hist->SetLineWidth(lineWidth); | |
3483 | hist->SetMarkerStyle(markerStyle); | |
3484 | hist->SetMarkerColor(markerColor); | |
3485 | hist->SetMarkerSize(markerSize); | |
3486 | } | |
33d501fa | 3487 | |
3488 | //____________________________________________________________________ | |
3489 | void AliTRDcheckESD::SetStyle(TAxis* axis, const Char_t* title, Float_t titleSize, Float_t titleOffset, Bool_t centerTitle, | |
3490 | Float_t labelSize) { | |
3491 | // | |
3492 | // Set style settings for axes | |
3493 | // | |
3494 | axis->SetTitle(title); | |
3495 | axis->SetTitleSize(titleSize); | |
3496 | axis->SetTitleOffset(titleOffset); | |
3497 | axis->CenterTitle(centerTitle); | |
3498 | axis->SetLabelSize(labelSize); | |
3499 | } | |
3500 | ||
3501 | //____________________________________________________________________ | |
3502 | void AliTRDcheckESD::FindIsolatedBCs(TH1D* bcHist, Bool_t isIsolated[3500]) { | |
3503 | // | |
3504 | // Find the isolated bunch crossings | |
3505 | // | |
3506 | Int_t isolationSize = 10; // number of free bunches in both directions | |
3507 | for(Int_t bcBin=1; bcBin<=bcHist->GetXaxis()->GetNbins(); ++bcBin) { | |
3508 | Int_t bc = TMath::Nint(bcHist->GetBinCenter(bcBin)); | |
3509 | if(bc<-0.001 || bc>3499.01) { | |
3510 | isIsolated[bc] = kFALSE; | |
3511 | continue; | |
3512 | } | |
3513 | Double_t entries = bcHist->GetBinContent(bcBin); | |
3514 | if(entries<0.001) { | |
3515 | isIsolated[bc] = kFALSE; | |
3516 | continue; // no entries | |
3517 | } | |
3518 | ||
3519 | // check isolation | |
3520 | isIsolated[bc] = kTRUE; | |
3521 | for(Int_t ibc = TMath::Max(1,bcBin-isolationSize); ibc <= TMath::Min(3499, bcBin+isolationSize); ++ibc) { | |
3522 | if(ibc==bcBin) continue; | |
3523 | if(bcHist->GetBinContent(ibc)>0.01) { | |
3524 | isIsolated[bc] = kFALSE; | |
3525 | break; | |
3526 | } | |
3527 | } | |
3528 | } // end loop over BC bins | |
3529 | ||
3530 | cout << "Isolated bunches: " << endl; | |
3531 | for(Int_t ibc=0; ibc<3500; ++ibc) | |
3532 | if(isIsolated[ibc]) cout << "BC #" << ibc << endl; | |
3533 | } |