]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - ESDCheck/AliTRDQATask.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Initial version of the example CTP configuration file (Roman)
[u/mrichter/AliRoot.git] / ESDCheck / AliTRDQATask.cxx
... / ...
CommitLineData
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/* $Id$ */
17
18//_________________________________________________________________________
19// An analysis task to check the TRD data in simulated data
20//
21//*-- Sylwester Radomski
22//////////////////////////////////////////////////////////////////////////////
23// track type codding
24//
25// tpci = kTPCin
26// tpco = kTPCout
27// tpcz = kTPCout && !kTRDout
28// trdo = kTRDout
29// trdr = kTRDref
30// trdz = kTRDout && !kTRDref
31//
32
33#include <TCanvas.h>
34#include <TChain.h>
35#include <TFile.h>
36#include <TGaxis.h>
37#include <TH1D.h>
38#include <TH2D.h>
39#include <TROOT.h>
40#include <TStyle.h>
41#include <TString.h>
42
43#include "AliTRDQATask.h"
44#include "AliESD.h"
45#include "AliLog.h"
46
47//______________________________________________________________________________
48AliTRDQATask::AliTRDQATask(const char *name) :
49 AliAnalysisTask(name,""),
50 fChain(0),
51 fESD(0)
52{
53 // Constructor.
54 // Input slot #0 works with an Ntuple
55 DefineInput(0, TChain::Class());
56 // Output slot #0 writes into a TH1 container
57 DefineOutput(0, TObjArray::Class()) ;
58}
59
60//______________________________________________________________________________
61void AliTRDQATask::ConnectInputData(const Option_t *)
62{
63 // Initialisation of branch container and histograms
64
65 AliInfo(Form("*** Initialization of %s", GetName())) ;
66
67 // Get input data
68 fChain = dynamic_cast<TChain *>(GetInputData(0)) ;
69 if (!fChain) {
70 AliError(Form("Input 0 for %s not found\n", GetName()));
71 return ;
72 }
73
74 // One should first check if the branch address was taken by some other task
75 char ** address = (char **)GetBranchAddress(0, "ESD");
76 if (address) {
77 fESD = (AliESD*)(*address);
78 } else {
79 fESD = new AliESD();
80 SetBranchAddress(0, "ESD", &fESD);
81 }
82}
83
84//________________________________________________________________________
85void AliTRDQATask::CreateOutputObjects()
86{
87 // create histograms
88
89 OpenFile(0) ;
90
91 fNTracks = new TH1D("ntracks", ";number of all tracks", 500, -0.5, 499.5);
92 fEventSize = new TH1D("evSize", ";event size (MB)", 100, 0, 5);
93
94 fTrackStatus = new TH1D("trackStatus", ";status bit", 32, -0.5, 31.5);
95 fKinkIndex = new TH1D("kinkIndex", ";kink index", 41, -20.5, 20.5);
96
97 fParIn = new TH1D("parIn", "Inner Plane", 2, -0.5, 1.5);
98 fParOut = new TH1D("parOut", "Outer Plane", 2, -0.5, 1.5);
99
100 fXIn = new TH1D("xIn", ";X at the inner plane (cm)", 200, 50, 250);
101 fXOut = new TH1D("xOut", ";X at the outer plane (cm)", 300, 50, 400);
102
103 const int knNameAlpha = 4;
104 const char *namesAlpha[knNameAlpha] = {"alphaTPCi", "alphaTPCo", "alphaTRDo", "alphaTRDr"};
105 //TH1D *fAlpha[4];
106 for(int i=0; i<knNameAlpha; i++) {
107 fAlpha[i] = new TH1D(namesAlpha[i], "alpha", 100, -4, 4);
108 }
109 fSectorTRD = new TH1D ("sectorTRD", ";sector TRD", 20, -0.5, 19.5);
110
111
112 // track parameters
113 const int knbits = 6;
114 const char *suf[knbits] = {"TPCi", "TPCo", "TPCz", "TRDo", "TRDr", "TRDz"};
115 for(int i=0; i<knbits; i++) {
116 fPt[i] = new TH1D(Form("pt%s",suf[i]), ";p_{T} (GeV/c);entries TPC", 50, 0, 10);
117 fTheta[i] = new TH1D(Form("theta%s", suf[i]), "theta (rad)", 100, -4, 4);
118 fSigmaY[i] = new TH1D(Form("sigmaY%s",suf[i]), ";sigma Y (cm)", 200, 0, 1);
119 fChi2[i] = new TH1D(Form("Chi2%s", suf[i]), ";#chi2 / ndf", 100, 0, 10);
120 fPlaneYZ[i] = new TH2D(Form("planeYZ%s", suf[i]), Form("%sy (cm);z (cm)", suf[i]),
121 100, -60, 60, 500, -500, 500);
122 }
123
124 // efficiency
125 fEffPt[0] = (TH1D*) fPt[0]->Clone(Form("eff_%s_%s", suf[0], suf[1]));
126 fEffPt[1] = (TH1D*) fPt[0]->Clone(Form("eff_%s_%s", suf[1], suf[3]));
127 fEffPt[2] = (TH1D*) fPt[0]->Clone(Form("eff_%s_%s", suf[3], suf[4]));
128 fEffPt[3] = (TH1D*) fPt[0]->Clone(Form("eff_%s_%s", suf[1], suf[4]));
129
130 for(int i=0; i<4; i++) {
131 fEffPt[i]->Sumw2();
132 fEffPt[i]->SetMarkerStyle(20);
133 fEffPt[i]->SetMinimum(0);
134 fEffPt[i]->SetMaximum(1.1);
135 }
136
137 // track features
138 fClustersTRD[0] = new TH1D("clsTRDo", "TRDo;number of clusters", 130, -0.5, 129.5);;
139 fClustersTRD[1] = new TH1D("clsTRDr", "TRDr;number of clusters", 130, -0.5, 129.5);;
140 fClustersTRD[2] = new TH1D("clsTRDz", "TRDz;number of clusters", 130, -0.5, 129.5);;
141
142 // for good refitted tracks only
143 fTime = new TH1D("time", ";time bin", 25, -0.5, 24.5);
144 fBudget = new TH1D("budget", ";material budget", 100, 0, 100);
145 fQuality = new TH1D("quality", ";track quality", 100, 0, 1.1);
146 fSignal = new TH1D("signal", ";signal", 100, 0, 1e3);
147
148 // dEdX and PID
149 fTrdSigMom = new TH2D("trdSigMom", ";momentum (GeV/c);signal", 100, 0, 3, 100, 0, 1e3);
150 fTpcSigMom = new TH2D("tpcSigMom", ";momentum (GeV/c);signal", 100, 0, 3, 100, 0, 200);
151
152 const char *pidName[6] = {"El", "Mu", "Pi", "K", "P", "Ch"};
153 for(int i=0; i<6; i++) {
154
155 // TPC
156 fTpcPID[i] = new TH1D(Form("tpcPid%s",pidName[i]), pidName[i], 100, 0, 1.5);
157 fTpcPID[i]->GetXaxis()->SetTitle("probability");
158
159 fTpcSigMomPID[i] = new TH2D(Form("tpcSigMom%s",pidName[i]), "", 100, 0, 3, 100, 0, 200);
160 fTpcSigMomPID[i]->SetTitle(Form("%s;momentum (GeV/c);signal",pidName[i]));
161
162 // TRD
163 fTrdPID[i] = new TH1D(Form("trdPid%s",pidName[i]), pidName[i], 100, 0, 1.5);
164 fTrdPID[i]->GetXaxis()->SetTitle("probability");
165
166 fTrdSigMomPID[i] = new TH2D(Form("trdSigMom%s",pidName[i]), "", 100, 0, 3, 100, 0, 1e3);
167 fTrdSigMomPID[i]->SetTitle(Form("%s;momentum (GeV/c);signal",pidName[i]));
168 }
169
170
171 // create output container
172 fOutputContainer = new TObjArray(150);
173
174 // register histograms to the container
175 int counter = 0;
176
177 fOutputContainer->AddAt(fNTracks, counter++);
178 fOutputContainer->AddAt(fEventSize, counter++);
179 fOutputContainer->AddAt(fTrackStatus, counter++);
180 fOutputContainer->AddAt(fKinkIndex, counter++);
181 fOutputContainer->AddAt(fParIn, counter++);
182 fOutputContainer->AddAt(fParOut, counter++);
183 fOutputContainer->AddAt(fXIn, counter++);
184 fOutputContainer->AddAt(fXOut, counter++);
185 fOutputContainer->AddAt(fAlpha[0], counter++);
186 fOutputContainer->AddAt(fAlpha[1], counter++);
187 fOutputContainer->AddAt(fAlpha[2], counter++);
188 fOutputContainer->AddAt(fAlpha[3], counter++);
189
190 fOutputContainer->AddAt(fSectorTRD, counter++);
191 for(int i=0; i<knbits; i++) {
192 fOutputContainer->AddAt(fPt[i], counter++);
193 fOutputContainer->AddAt(fTheta[i], counter++);
194 fOutputContainer->AddAt(fSigmaY[i], counter++);
195 fOutputContainer->AddAt(fChi2[i], counter++);
196 fOutputContainer->AddAt(fPlaneYZ[i], counter++);
197 }
198 fOutputContainer->AddAt(fEffPt[0], counter++);
199 fOutputContainer->AddAt(fEffPt[1], counter++);
200 fOutputContainer->AddAt(fEffPt[2], counter++);
201 fOutputContainer->AddAt(fEffPt[3], counter++);
202
203 fOutputContainer->AddAt(fClustersTRD[0], counter++);
204 fOutputContainer->AddAt(fClustersTRD[1], counter++);
205 fOutputContainer->AddAt(fClustersTRD[2], counter++);
206 fOutputContainer->AddAt(fTime, counter++);
207 fOutputContainer->AddAt(fBudget, counter++);
208 fOutputContainer->AddAt(fQuality, counter++);
209 fOutputContainer->AddAt(fSignal, counter++);
210 fOutputContainer->AddAt(fTrdSigMom, counter++);
211 fOutputContainer->AddAt(fTpcSigMom, counter++);
212 for(int i=0; i<6; i++) {
213 fOutputContainer->AddAt(fTpcPID[i], counter++);
214 fOutputContainer->AddAt(fTpcSigMomPID[i], counter++);
215 fOutputContainer->AddAt(fTrdPID[i], counter++);
216 fOutputContainer->AddAt(fTrdSigMomPID[i], counter++);
217 }
218
219 //AliInfo(Form("Number of histograms = %d", counter));
220
221 }
222
223//______________________________________________________________________________
224void AliTRDQATask::Exec(Option_t *)
225{
226 // Process one event
227
228 Long64_t entry = fChain->GetReadEntry() ;
229
230 // Processing of one event
231
232 if (!fESD) {
233 AliError("fESD is not connected to the input!") ;
234 return ;
235 }
236
237 if ( !((entry-1)%100) )
238 AliInfo(Form("%s ----> Processing event # %lld", (dynamic_cast<TChain *>(fChain))->GetFile()->GetName(), entry)) ;
239
240 int nTracks = fESD->GetNumberOfTracks();
241 fNTracks->Fill(nTracks);
242
243 // track loop
244 for(int i=0; i<nTracks; i++) {
245
246 AliESDtrack *track = fESD->GetTrack(i);
247 const AliExternalTrackParam *paramOut = track->GetOuterParam();
248 const AliExternalTrackParam *paramIn = track->GetInnerParam();
249
250 fParIn->Fill(!!paramIn);
251 if (!paramIn) continue;
252 fXIn->Fill(paramIn->GetX());
253
254 fParOut->Fill(!!paramOut);
255 if (!paramOut) continue;
256 fXOut->Fill(paramOut->GetX());
257
258 int sector = GetSector(paramOut->GetAlpha());
259 if (!CheckSector(sector)) continue;
260 fSectorTRD->Fill(sector);
261
262 fKinkIndex->Fill(track->GetKinkIndex(0));
263 if (track->GetKinkIndex(0)) continue;
264
265 UInt_t u = 1;
266 UInt_t status = track->GetStatus();
267 for(int bit=0; bit<32; bit++)
268 if (u<<bit & status) fTrackStatus->Fill(bit);
269
270 const int knbits = 6;
271 int bit[6] = {0,0,0,0,0,0};
272 bit[0] = status & AliESDtrack::kTPCin;
273 bit[1] = status & AliESDtrack::kTPCout;
274 bit[2] = (status & AliESDtrack::kTPCout) && !(status & AliESDtrack::kTRDout);
275 bit[3] = status & AliESDtrack::kTRDout;
276 bit[4] = status & AliESDtrack::kTRDrefit;
277 bit[5] = (status & AliESDtrack::kTRDout) && !(status & AliESDtrack::kTRDrefit);
278
279
280 // transverse momentum
281 const double *val = track->GetParameter(); // parameters at the vertex
282 double pt = 1./TMath::Abs(val[4]);
283
284 for(int b=0; b<knbits; b++) {
285 if (bit[b]) {
286 fPt[b]->Fill(pt);
287 fTheta[b]->Fill(val[3]);
288 fSigmaY[b]->Fill(TMath::Sqrt(paramOut->GetSigmaY2()));
289 fChi2[b]->Fill(track->GetTRDchi2()/track->GetTRDncls());
290 fPlaneYZ[b]->Fill(paramOut->GetY(), paramOut->GetZ());
291 }
292 }
293
294 // sectors
295 if (bit[1]) {
296 fAlpha[0]->Fill(paramIn->GetAlpha());
297 fAlpha[1]->Fill(paramOut->GetAlpha());
298 }
299
300 if (bit[3]) fAlpha[2]->Fill(paramOut->GetAlpha());
301 if (bit[4]) fAlpha[3]->Fill(paramOut->GetAlpha());
302
303 // clusters
304 for(int b=0; b<3; b++)
305 if (bit[3+b]) fClustersTRD[b]->Fill(track->GetTRDncls());
306
307 // refitted only
308 if (!bit[4]) continue;
309
310 fQuality->Fill(track->GetTRDQuality());
311 fBudget->Fill(track->GetTRDBudget());
312 fSignal->Fill(track->GetTRDsignal());
313
314 fTrdSigMom->Fill(track->GetP(), track->GetTRDsignal());
315 fTpcSigMom->Fill(track->GetP(), track->GetTPCsignal());
316
317 // PID only
318 if (status & AliESDtrack::kTRDpid) {
319
320 for(int l=0; l<6; l++) fTime->Fill(track->GetTRDTimBin(l));
321
322 // fill pid histograms
323 double trdr0 = 0, tpcr0 = 0;
324 int trdBestPid = 5, tpcBestPid = 5; // charged
325 const double kminPidValue = 0.9;
326
327 double pp[5];
328 track->GetTPCpid(pp); // ESD inconsequence
329
330 for(int pid=0; pid<5; pid++) {
331
332 trdr0 += track->GetTRDpid(pid);
333 tpcr0 += pp[pid];
334
335 fTrdPID[pid]->Fill(track->GetTRDpid(pid));
336 fTpcPID[pid]->Fill(pp[pid]);
337
338 if (track->GetTRDpid(pid) > kminPidValue) trdBestPid = pid;
339 if (pp[pid] > kminPidValue) tpcBestPid = pid;
340 }
341
342 fTrdPID[5]->Fill(trdr0); // check unitarity
343 fTrdSigMomPID[trdBestPid]->Fill(track->GetP(), track->GetTRDsignal());
344
345 fTpcPID[5]->Fill(tpcr0); // check unitarity
346 fTpcSigMomPID[tpcBestPid]->Fill(track->GetP(), track->GetTPCsignal());
347 }
348
349 }
350
351 CalculateEff();
352 PostData(0, fOutputContainer);
353}
354
355//______________________________________________________________________________
356void AliTRDQATask::Terminate(Option_t *)
357{
358 // Processing when the event loop is ended
359 fOutputContainer = (TObjArray*)GetOutputData(0);
360 int counter = 0;
361 fNTracks = (TH1D*)fOutputContainer->At(counter++);
362 fEventSize = (TH1D*)fOutputContainer->At(counter++);
363 fTrackStatus = (TH1D*)fOutputContainer->At(counter++);
364 fKinkIndex = (TH1D*)fOutputContainer->At(counter++);
365 fParIn = (TH1D*)fOutputContainer->At(counter++);
366 fParOut = (TH1D*)fOutputContainer->At(counter++);
367 fXIn = (TH1D*)fOutputContainer->At(counter++);
368 fXOut = (TH1D*)fOutputContainer->At(counter++);
369 fAlpha[0] = (TH1D*)fOutputContainer->At(counter++);
370 fAlpha[1] = (TH1D*)fOutputContainer->At(counter++);
371 fAlpha[2] = (TH1D*)fOutputContainer->At(counter++);
372 fAlpha[3] = (TH1D*)fOutputContainer->At(counter++);
373
374 fSectorTRD = (TH1D*)fOutputContainer->At(counter++);
375 const int knbits = 6;
376 for(int i=0; i<knbits; i++) {
377 fPt[i] = (TH1D*)fOutputContainer->At(counter++);
378 fTheta[i] = (TH1D*)fOutputContainer->At(counter++);
379 fSigmaY[i] = (TH1D*)fOutputContainer->At(counter++);
380 fChi2[i] = (TH1D*)fOutputContainer->At(counter++);
381 fPlaneYZ[i] = (TH2D*)fOutputContainer->At(counter++);
382 }
383 fEffPt[0] = (TH1D*)fOutputContainer->At(counter++);
384 fEffPt[1] = (TH1D*)fOutputContainer->At(counter++);
385 fEffPt[2] = (TH1D*)fOutputContainer->At(counter++);
386 fEffPt[3] = (TH1D*)fOutputContainer->At(counter++);
387
388 fClustersTRD[0] = (TH1D*)fOutputContainer->At(counter++);
389 fClustersTRD[1] = (TH1D*)fOutputContainer->At(counter++);
390 fClustersTRD[2] = (TH1D*)fOutputContainer->At(counter++);
391 fTime = (TH1D*)fOutputContainer->At(counter++);
392 fBudget = (TH1D*)fOutputContainer->At(counter++);
393 fQuality = (TH1D*)fOutputContainer->At(counter++);
394 fSignal = (TH1D*)fOutputContainer->At(counter++);
395 fTrdSigMom = (TH2D*)fOutputContainer->At(counter++);
396 fTpcSigMom = (TH2D*)fOutputContainer->At(counter++);
397 for(int i=0; i<6; i++) {
398 fTpcPID[i] = (TH1D*)fOutputContainer->At(counter++);
399 fTpcSigMomPID[i] = (TH2D*)fOutputContainer->At(counter++);
400 fTrdPID[i] = (TH1D*)fOutputContainer->At(counter++);
401 fTrdSigMomPID[i] = (TH2D*)fOutputContainer->At(counter++);
402 }
403
404 // create efficiency histograms
405 Bool_t problem = kFALSE ;
406 AliInfo(Form(" *** %s Report:", GetName())) ;
407
408 CalculateEff();
409
410 DrawESD() ;
411 DrawGeoESD() ;
412 //DrawConvESD() ;
413 DrawPidESD() ;
414
415 char line[1024] ;
416 sprintf(line, ".!tar -zcf %s.tar.gz *.eps", GetName()) ;
417 gROOT->ProcessLine(line);
418
419 AliInfo(Form("!!! All the eps files are in %s.tar.gz !!!", GetName())) ;
420
421 TString report ;
422 if(problem)
423 report="Problems found, please check!!!";
424 else
425 report="OK";
426
427 AliInfo(Form("*** %s Summary Report: %s\n",GetName(), report.Data())) ;
428
429}
430
431//______________________________________________________________________________
432const int AliTRDQATask::GetSector(const double alpha) const
433{
434 // Gets the sector number
435
436 double size = TMath::DegToRad() * 20.;
437 int sector = (int)((alpha + TMath::Pi())/size);
438 return sector;
439}
440
441//______________________________________________________________________________
442const int AliTRDQATask::CheckSector(const int sector) const
443{
444 // Checks the sector number
445 const int knSec = 8;
446 int sec[] = {2,3,5,6,11,12,13,15};
447
448 for(int i=0; i<knSec; i++)
449 if (sector == sec[i]) return 1;
450
451 return 0;
452}
453
454//______________________________________________________________________________
455void AliTRDQATask::CalculateEff()
456{
457 // calculates the efficiency
458
459 for(int i=0; i<4; i++) fEffPt[i]->Reset();
460
461 fEffPt[0]->Add(fPt[1]);
462 fEffPt[0]->Divide(fPt[0]);
463
464 fEffPt[1]->Add(fPt[3]);
465 fEffPt[1]->Divide(fPt[1]);
466
467 fEffPt[2]->Add(fPt[4]);
468 fEffPt[2]->Divide(fPt[3]);
469
470 fEffPt[3]->Add(fPt[4]);
471 fEffPt[3]->Divide(fPt[1]);
472}
473
474//______________________________________________________________________________
475void AliTRDQATask::DrawESD() const
476{
477 // Makes a few plots
478
479 TCanvas * cTRD = new TCanvas("cTRD", "TRD ESD Test", 400, 10, 600, 700) ;
480 cTRD->Divide(6,3) ;
481
482 gROOT->SetStyle("Plain");
483 gStyle->SetPalette(1);
484 gStyle->SetOptStat(0);
485
486 TGaxis::SetMaxDigits(3);
487
488 gStyle->SetLabelFont(52, "XYZ");
489 gStyle->SetTitleFont(62, "XYZ");
490 gStyle->SetPadRightMargin(0.02);
491
492 // draw all
493
494 const int knplots = 18;
495 const int knover[knplots] = {1,1,1,4,1,1,1,1,1,1,2,1,1,3,1,1,1,1};
496 const int knnames = 24;
497 const char *names[knnames] = {
498 "ntracks", "kinkIndex", "trackStatus",
499 "ptTPCi", "ptTPCo", "ptTRDo", "ptTRDr", "ptTPCz", "ptTRDz",
500 "eff_TPCi_TPCo", "eff_TPCo_TRDo", "eff_TRDo_TRDr", "eff_TPCo_TRDr",
501 "clsTRDo", "clsTRDr", "clsTRDz",
502 "alphaTPCi", "alphaTPCo", "alphaTRDo", "alphaTRDr", "sectorTRD",
503 "time", "budget", "signal"
504 };
505
506 const int klogy[knnames] = {
507 1,1,1,
508 1,1,1,
509 0,0,0,0,
510 1,1,
511 0,0,0,0,0,
512 0,1,1
513 };
514
515 int nhist=0;
516 for(int i=0; i<knplots; i++) {
517 cTRD->cd(i+1) ;
518
519 // new TCanvas(names[i], names[nhist], 500, 300);
520
521 for(int j=0; j<knover[i]; j++) {
522 TH1D *hist = dynamic_cast<TH1D*>(gDirectory->FindObject(names[nhist++]));
523 if (!hist) continue;
524 if (hist->GetMaximum() > 0 )
525 gPad->SetLogy(klogy[i]);
526 if (strstr(hist->GetName(), "eff")) {
527 hist->SetMarkerStyle(20);
528 hist->SetMinimum(0);
529 hist->SetMaximum(1.2);
530 }
531
532 if (!j) hist->Draw();
533 else hist->Draw("SAME");
534 }
535 }
536 cTRD->Print("TRD_ESD.eps");
537}
538
539//______________________________________________________________________________
540void AliTRDQATask::DrawGeoESD() const
541{
542 // Makes a few plots
543
544 TCanvas * cTRDGeo = new TCanvas("cTRDGeo", "TRD ESDGeo Test", 400, 10, 600, 700) ;
545 cTRDGeo->Divide(4,2) ;
546
547 gStyle->SetOptStat(0);
548 TGaxis::SetMaxDigits(3);
549
550 gStyle->SetLabelFont(52, "XYZ");
551 gStyle->SetTitleFont(62, "XYZ");
552
553 gStyle->SetPadTopMargin(0.06);
554 gStyle->SetTitleBorderSize(0);
555
556 // draw all
557 const int knnames = 7;
558 const char *names[knnames] = {
559 "xIn", "xOut",
560 "planeYZTPCo", "planeYZTPCz", "planeYZTRDo", "planeYZTRDr", "planeYZTRDz",
561 };
562
563 const char *opt[knnames] = {
564 "", "",
565 "colz","colz", "colz", "colz", "colz"
566 };
567
568 const int klogy[knnames] = {
569 1,1,
570 0,0,0,0,0
571 };
572
573 for(int i=0; i<knnames; i++) {
574 cTRDGeo->cd(i+1) ;
575 TH1D *hist = dynamic_cast<TH1D*>(gDirectory->FindObject(names[i]));
576 if (!hist) continue;
577
578 //if (i<2) new TCanvas(names[i], names[i], 500, 300);
579 //else new TCanvas(names[i], names[i], 300, 900);
580
581 if (hist->GetMaximum() > 0 )
582 gPad->SetLogy(klogy[i]);
583 if (strstr(opt[i],"colz")) gPad->SetRightMargin(0.1);
584
585 hist->Draw(opt[i]);
586 AliInfo(Form("%s\t%d", names[i], hist->GetEntries()));
587 }
588
589 cTRDGeo->Print("TRD_Geo.eps");
590}
591
592//______________________________________________________________________________
593void AliTRDQATask::DrawConvESD() const
594{
595 // Makes a few plots
596
597 AliInfo("Plotting....") ;
598 TCanvas * cTRDConv = new TCanvas("cTRDConv", "TRD ESDConv Test", 400, 10, 600, 700) ;
599 cTRDConv->Divide(3,2) ;
600
601 gROOT->SetStyle("Plain");
602 gROOT->ForceStyle();
603 gStyle->SetPalette(1);
604
605 TGaxis::SetMaxDigits(3);
606
607 gStyle->SetLabelFont(52, "XYZ");
608 gStyle->SetTitleFont(62, "XYZ");
609 gStyle->SetPadRightMargin(0.02);
610
611 const int knnames = 9;
612 const int knplots = 5;
613 const int knover[knplots] = {3,1,1,3,1};
614
615 const char *names[knnames] = {
616 "sigmaYTPCo","sigmaYTRDo", "sigmaYTRDr", "sigmaYTPCz", "sigmaYTRDz",
617 "Chi2TPCo", "Chi2TRDo", "Chi2TRDr", "Chi2TRDz"
618 };
619
620 const char *opt[knplots] = {
621 "", "", "","","",
622 };
623
624 const int klogy[knplots] = {
625 0,0,0,1,1
626 };
627
628 int nhist = 0;
629 for(int i=0; i<knplots; i++) {
630 cTRDConv->cd(i+1) ;
631 //new TCanvas(names[i], names[i], 500, 300);
632 if (strstr(opt[i],"colz")) gPad->SetRightMargin(0.1);
633
634 for(int j=0; j<knover[i]; j++) {
635 TH1D *hist = dynamic_cast<TH1D*>(gDirectory->FindObject(names[nhist++]));
636 if ( hist->GetMaximum() > 0 )
637 gPad->SetLogy(klogy[i]);
638 if (!j) hist->Draw(opt[i]);
639 else hist->Draw("same");
640 }
641
642 }
643 cTRDConv->Print("TRD_Conv.eps");
644}
645
646//______________________________________________________________________________
647void AliTRDQATask::DrawPidESD() const
648{
649 // Makes a few plots
650
651 TCanvas * cTRDPid = new TCanvas("cTRDPid", "TRD ESDPid Test", 400, 10, 600, 700) ;
652 cTRDPid->Divide(9,3) ;
653
654 gROOT->SetStyle("Plain");
655 gROOT->ForceStyle();
656 gStyle->SetPalette(1);
657 gStyle->SetOptStat(0);
658
659 TGaxis::SetMaxDigits(3);
660
661 gStyle->SetLabelFont(52, "XYZ");
662 gStyle->SetTitleFont(62, "XYZ");
663
664 gStyle->SetPadTopMargin(0.05);
665 gStyle->SetPadRightMargin(0.02);
666
667 // draw all
668
669 const int knnames = 27;
670 const char *names[knnames] = {
671
672 "signal", "trdSigMom", "tpcSigMom",
673
674 "trdPidEl", "trdPidMu", "trdPidPi", "trdPidK", "trdPidP", "trdPidCh",
675 "trdSigMomEl", "trdSigMomMu", "trdSigMomPi", "trdSigMomK", "trdSigMomP", "trdSigMomCh",
676
677 "tpcPidEl", "tpcPidMu", "tpcPidPi", "tpcPidK", "tpcPidP", "tpcPidCh",
678 "tpcSigMomEl", "tpcSigMomMu", "tpcSigMomPi", "tpcSigMomK", "tpcSigMomP", "tpcSigMomCh"
679
680 };
681
682 const char *opt[knnames] = {
683
684 "", "colz", "colz",
685
686 "", "", "", "", "", "" ,
687 "colz", "colz", "colz", "colz", "colz", "colz",
688
689 "", "", "", "", "", "" ,
690 "colz", "colz", "colz", "colz", "colz", "colz"
691 };
692
693 const int klogy[knnames] = {
694
695 0,0,0,
696
697 1,1,1,1,1,1,
698 0,0,0,0,0,0,
699
700 1,1,1,1,1,1,
701 0,0,0,0,0,0
702 };
703
704 for(int i=0; i<knnames; i++) {
705 cTRDPid->cd(i+1) ;
706
707 TH1D *hist = dynamic_cast<TH1D*>(gDirectory->FindObject(names[i]));
708 if (!hist) continue;
709
710 //new TCanvas(names[i], names[i], 500, 300);
711 if ( hist->GetMaximum() > 0 )
712 gPad->SetLogy(klogy[i]);
713 if (strstr(opt[i],"colz")) gPad->SetRightMargin(0.1);
714
715 if (strstr(names[i],"sigMom")) gPad->SetLogz(1);
716 if (strstr(names[i],"SigMom")) gPad->SetLogz(1);
717
718 hist->Draw(opt[i]);
719 AliInfo(Form("%s\t%d", names[i], hist->GetEntries()));
720 }
721 cTRDPid->Print("TRD_Pid.eps");
722}