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