Radical performance improvement
[u/mrichter/AliRoot.git] / TRD / AliTRDQADataMaker.cxx
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 //                                                                        //
20 //  Produces the data needed to calculate the quality assurance.          //
21 //  All data must be mergeable objects.                                   //
22 //                                                                        //
23 //  Author:                                                               //
24 //    Sylwester Radomski (radomski@physi.uni-heidelberg.de)               //
25 //                                                                        //
26 ////////////////////////////////////////////////////////////////////////////
27
28 // --- ROOT system ---
29 #include <TClonesArray.h>
30 #include <TFile.h> 
31 #include <TH1D.h> 
32 #include <TH2D.h>
33 #include <TH3D.h>
34 #include <TProfile.h>
35 #include <TF1.h>
36 #include <TCanvas.h>
37 #include <TStopwatch.h>
38
39 // --- AliRoot header files ---
40 #include "AliESDEvent.h"
41 #include "AliLog.h"
42 #include "AliTRDdigit.h"
43 #include "AliTRDhit.h"
44 #include "AliTRDcluster.h"
45 #include "AliTRDQADataMaker.h"
46 #include "AliTRDdigitsManager.h"
47 #include "AliTRDgeometry.h"
48 #include "AliTRDdataArrayI.h"
49 #include "AliTRDrawStreamTB.h"
50 #include "AliTRDRawStreamV2.h"
51
52 #include "AliQAChecker.h"
53
54 ClassImp(AliTRDQADataMaker)
55
56 //____________________________________________________________________________ 
57   AliTRDQADataMaker::AliTRDQADataMaker() : 
58   AliQADataMaker(AliQA::GetDetName(AliQA::kTRD), "TRD Quality Assurance Data Maker")
59 {
60   //
61   // Default constructor
62 }
63
64 //____________________________________________________________________________ 
65 AliTRDQADataMaker::AliTRDQADataMaker(const AliTRDQADataMaker& qadm) :
66   AliQADataMaker()
67 {
68   //
69   // Copy constructor 
70   //
71
72   SetName((const char*)qadm.GetName()) ; 
73   SetTitle((const char*)qadm.GetTitle()); 
74
75 }
76
77 //__________________________________________________________________
78 AliTRDQADataMaker& AliTRDQADataMaker::operator=(const AliTRDQADataMaker& qadm)
79 {
80   //
81   // Equal operator.
82   //
83
84   this->~AliTRDQADataMaker();
85   new(this) AliTRDQADataMaker(qadm);
86   return *this;
87
88 }
89
90 //____________________________________________________________________________ 
91 void AliTRDQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list)
92 {
93   //
94   // Detector specific actions at end of cycle
95   //
96   //TStopwatch watch;
97   //watch.Start();
98
99   //AliInfo(Form("EndOfCycle", "Fitting RecPoints %d", task))
100   TH1D *hist = new TH1D("fitHist", "", 200, -0.5, 199.5);
101  
102   if (task == AliQA::kRECPOINTS) {
103
104     //list->Print();
105     
106     // Rec points full chambers
107     for (Int_t i=0; i<540; i++) {
108         
109       //TH1D *h = ((TH2D*)list->At(1))->ProjectionY(Form("qaTRD_recPoints_amp_%d",i), i+1, i+1);
110       hist->Reset();
111       for(Int_t b=1; b<hist->GetXaxis()->GetNbins()-1; b++) {
112         Double_t xvalue = hist->GetBinCenter(b);
113         Int_t bin = ((TH2D*)list->At(1))->FindBin(i,xvalue);
114         Double_t value =  ((TH2D*)list->At(1))->GetBinContent(bin);
115         hist->SetBinContent(b, value);
116       }
117       
118       //printf("Sum = %d %f\n", i, hist->GetSum());
119       if (hist->GetSum() < 100) continue; // chamber not present
120       
121       hist->Fit("landau", "q0", "goff", 10, 180);
122       TF1 *fit = hist->GetFunction("landau");
123       ((TH1D*)list->At(12))->Fill(fit->GetParameter(1));
124       ((TH1D*)list->At(13))->Fill(fit->GetParameter(2));
125     }
126  
127     // time-bin by time-bin
128     for (Int_t i=0; i<540; i++) {
129         
130       //TH1D *test = ((TH3D*)list->At(10))->ProjectionZ(Form("ampTime_%d",i), i+1, i+1, 0, 35);     
131       //if (test->GetSum() < 100) continue;
132       
133       //AliInfo(Form("fitting det = %d", i));
134       
135       for(Int_t j=0; j<35; j++) {
136         
137         //TH1D *h =  ((TH3D*)list->At(10))->ProjectionZ(Form("ampTime_%d",i), i+1, i+1, j+1, j+1);     
138         hist->Reset();
139         for(Int_t b=1; b<hist->GetXaxis()->GetNbins()-1; b++) {
140           Double_t xvalue = hist->GetBinCenter(b);
141           Int_t bin = ((TH3D*)list->At(10))->FindBin(i,j,xvalue);
142           Double_t value =  ((TH3D*)list->At(10))->GetBinContent(bin);
143           //printf("v = %f\n", value);
144           hist->SetBinContent(b, value);
145         }
146         
147         if (hist->GetSum() < 100) continue;
148         //printf("fitting %d %d %f\n", i, j, hist->GetSum());
149
150         hist->Fit("landau", "q0", "goff", 10, 180);
151         TF1 *fit = hist->GetFunction("landau");
152         
153         Int_t sm = i/18;
154         Int_t det = i%18;
155         TH2D *h2 = (TH2D*)list->At(14+sm);
156         Int_t bin = h2->FindBin(det,j);
157         // printf("%d %d %d\n", det, j, bin);
158         h2->SetBinContent(bin, fit->GetParameter(1));
159       }
160     }
161   }
162   
163   delete hist;
164   
165   // call the checker
166   AliQAChecker::Instance()->Run(AliQA::kTRD, task, list) ;    
167
168   //watch.Stop();
169   //watch.Print();
170 }
171
172 //____________________________________________________________________________ 
173 void AliTRDQADataMaker::InitESDs()
174 {
175   //
176   // Create ESDs histograms in ESDs subdir
177   //
178
179   const Int_t kNhist = 19;
180   TH1 *hist[kNhist];
181   Int_t histoCounter = -1 ;
182
183   hist[++histoCounter] = new TH1D("qaTRD_esd_ntracks", ":Number of tracks", 300, -0.5, 299.5);
184   hist[++histoCounter] = new TH1D("qaTRD_esd_sector", ":Sector", 18, -0.5, 17.7);
185   hist[++histoCounter] = new TH1D("qaTRD_esd_bits", ";Bits", 64, -0.5, 63.5);
186
187   const Int_t knbits = 6;
188   const char *suf[knbits] = {"TPCi", "TPCo", "TPCz", "TRDo", "TRDr", "TRDz"};
189
190   for(Int_t i=0; i<knbits; i++) {
191     hist[++histoCounter] = new TH1D(Form("qaTRD_esd_pt%s",suf[i]), ";p_{T} (GeV/c);", 50, 0, 10);
192     hist[++histoCounter] = new TH1D(Form("qaTRD_esd_trdz%s", suf[i]), ";z (cm)", 200, -400, 400); 
193   }
194
195   hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDo", "TRDo;number of clusters", 130, -0.5, 129.5);;
196   hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDr", "TRDr;number of clusters", 130, -0.5, 129.5);;
197   hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDz", "TRDz;number of clusters", 130, -0.5, 129.5);;
198   //hist[++histoCounter] = new TH1D("qaTRD_esd_clsRatio", ";cluster ratio", 100, 0., 1.3);;
199
200   hist[++histoCounter] = new TH2D("qaTRD_esd_sigMom", ";momentum (GeV/c);signal", 100, 0, 5, 200, 0, 1e3);
201
202   for(Int_t i=0; i<=histoCounter; i++) {
203     //hist[i]->Sumw2();
204     Add2ESDsList(hist[i], i);
205   }
206
207 }
208
209 //____________________________________________________________________________ 
210 void AliTRDQADataMaker::InitHits()
211 {
212   //
213   // Create Hits histograms in Hits subdir
214   //
215
216   const Int_t kNhist = 4;
217   TH1D *hist[kNhist];
218
219   hist[0] = new TH1D("qaTRD_hits_det", ";Detector Id of the hit", 540, -0.5, 539.5) ; 
220
221   hist[1] = new TH1D("qaTRD_hist_Qdrift", ";Charge from tracks", 100, 0, 100);
222   hist[2] = new TH1D("qaTRD_hist_Qamp", ";Charge from TRD photon", 100, 0, 100);
223   hist[3] = new TH1D("qaTRD_hist_Qphoton", ";Charge from TRD photon", 100, 0, 100);
224
225   for(Int_t i=0; i<kNhist; i++) {
226     //hist[i]->Sumw2();
227     Add2HitsList(hist[i], i);
228   }
229
230 }
231
232 //____________________________________________________________________________ 
233 void AliTRDQADataMaker::InitDigits()
234 {
235   //
236   // Create Digits histograms in Digits subdir
237   //
238
239   const Int_t kNhist = 3;
240   TH1D *hist[kNhist];
241
242   hist[0] = new TH1D("qaTRD_digits_det", ";Detector Id of the digit", 540, -0.5, 539.5);
243   hist[1] = new TH1D("qaTRD_digits_time", ";Time bin", 40, -0.5, 39.5);
244   hist[2] = new TH1D("qaTRD_digits_amp", ";Amplitude", 100, 0, 100.);
245
246   for(Int_t i=0; i<kNhist; i++) {
247     hist[i]->Sumw2();
248     Add2DigitsList(hist[i], i);
249   }
250 }
251
252 //____________________________________________________________________________ 
253 void AliTRDQADataMaker::InitRecPoints()
254 {
255   //
256   // Create Reconstructed Points histograms in RecPoints subdir
257   //
258
259   const Int_t kNhist = 14 + 18;
260   TH1 *hist[kNhist];
261
262   hist[0] = new TH1D("qaTRD_recPoints_det", ";Detector ID of the cluster", 540, -0.5, 539.5);
263   hist[1] = new TH2D("qaTRD_recPoints_amp", ";Amplitude", 540, -0.5, 539, 200, -0.5, 199.5);
264   hist[2] = new TH1D("qaTRD_recPoints_npad", ";Number of Pads", 12, -0.5, 11.5);
265
266   hist[3] = new TH1D("qaTRD_recPoints_dist2", ";residuals [2pad]", 100, -1, 1);
267   hist[4] = new TH1D("qaTRD_recPoints_dist3", ";residuals [3pad]", 100, -1, 1);
268   hist[5] = new TH1D("qaTRD_recPoints_dist4", ";residuals [4pad]", 100, -1, 1);
269   hist[6] = new TH1D("qaTRD_recPoints_dist5", ";residuals [5pad]", 100, -1, 1);
270
271   hist[7] = new TH2D("qaTRD_recPoints_rowCol", ";row;col", 16, -0.5, 15.5, 145, -0.5, 144.5);
272   hist[8] = new TH1D("qaTRD_recPoints_time", ";time bin", 35, -0.5, 34.5);
273   hist[9] = new TH1D("qaTRD_recPoints_nCls", ";number of clusters", 500, -0.5, 499.5);
274
275   hist[10] = new TH3D("qaTRD_recPoints_sigTime", ";chamber;time bin;signal", 
276                       540, -0.5, 539.5, 35, -0.5, 34.5, 200, 0.5, 199.5);
277   hist[11] = new TProfile("qaTRD_recPoints_prf", ";distance;center of gravity"
278                          , 120, -0.6, 0.6, -1.2, 1.2, "");
279
280   hist[12] = new TH1D("qaTRD_recPoints_ampMPV", ";amplitude MPV", 100, 0, 100);
281   hist[13] = new TH1D("qaTRD_recPoints_ampSigma", ";amplitude Sigma", 100, 0, 100); 
282
283   for(Int_t i=0; i<18; i++) {
284     hist[14+i] = new TH2D(Form("qaTRD_recPoints_sigTime_sm%d",i), Form("sm%d;det;time bin"), 
285                         30, -0.5, 29.5, 35, -0.5, 34.5);
286     hist[14+i]->SetMinimum(20);
287     hist[14+i]->SetMaximum(40);
288   }
289
290   for(Int_t i=0; i<kNhist; i++) {
291     //hist[i]->Sumw2();
292     Add2RecPointsList(hist[i], i);
293   }
294
295 }
296
297 //____________________________________________________________________________ 
298 void AliTRDQADataMaker::InitRaws()
299 {
300   //
301   // create Raws histograms in Raws subdir
302   //
303
304   const Int_t kSM = 18;
305   //const Int_t kNCh = 540;
306   const Int_t kNhist = 4+kSM;
307   TH1D *hist[kNhist];
308
309   // four histograms to be published
310   hist[0] = new TH1D("qaTRD_raws_det", ";detector", 540, -0.5, 539.5);
311   hist[1] = new TH1D("qaTRD_raws_sig", ";signal", 100, -0.5, 99.5);
312   hist[2] = new TH1D("qaTRD_raws_timeBin", ";time bin", 40, -0.5, 39.5); 
313   hist[3] = new TH1D("qaTRD_raws_smId", ";supermodule", 18, -0.5, 17.5);
314   //
315   
316   // one double per MCM (not published)
317   const Int_t kNMCM = 30 * 8 * 16;
318   for(Int_t i=0; i<kSM; i++)
319     hist[4+i] = new TH1D(Form("qaTRD_raws_sm%d",i),"",kNMCM, -0.5, kNMCM-0.5); 
320   
321   // register
322   for(Int_t i=0; i<kNhist; i++) {
323     //hist[i]->Sumw2();
324     Add2RawsList(hist[i], i);
325   }
326
327 }
328
329 //____________________________________________________________________________ 
330 void AliTRDQADataMaker::InitSDigits()
331 {
332   //
333   // Create SDigits histograms in SDigits subdir
334   //
335
336   const Int_t kNhist = 3;
337   TH1D *hist[kNhist];
338
339   hist[0] = new TH1D("qaTRD_sdigits_det", ";Detector Id of the digit", 540, -0.5, 539.5);
340   hist[1] = new TH1D("qaTRD_sdigits_time", ";Time bin", 40, -0.5, 39.5);
341   hist[2] = new TH1D("qaTRD_sdigits_amp", ";Amplitude", 100, 0, 1e7);
342
343   for(Int_t i=0; i<kNhist; i++) {
344     hist[i]->Sumw2();
345     Add2SDigitsList(hist[i], i);
346   }
347
348 }
349
350 //____________________________________________________________________________
351 void AliTRDQADataMaker::MakeESDs(AliESDEvent * esd)
352 {
353   //
354   // Make QA data from ESDs
355   //
356
357   Int_t nTracks = esd->GetNumberOfTracks();
358   GetESDsData(0)->Fill(nTracks);
359
360   // track loop
361   for (Int_t i=0; i<nTracks; i++) {
362
363     AliESDtrack *track = esd->GetTrack(i);
364     const AliExternalTrackParam *paramOut = track->GetOuterParam();
365     const AliExternalTrackParam *paramIn = track->GetInnerParam();
366
367     // long track ..
368     if (!paramIn) continue;
369     if (!paramOut) continue;
370
371     // not a kink
372     if (track->GetKinkIndex(0) > 0) continue; 
373
374     Double_t extZ = GetExtZ(paramIn);
375     if (TMath::Abs(extZ) > 320) continue; // acceptance cut
376
377     // .. in the acceptance
378     Int_t sector = GetSector(paramOut->GetAlpha());
379     GetESDsData(1)->Fill(sector);
380
381     UInt_t u = 1;
382     UInt_t status = track->GetStatus();
383     for(Int_t bit=0; bit<32; bit++) 
384       if (u<<bit & status) GetESDsData(2)->Fill(bit);
385
386     const Int_t knbits = 6; 
387     Int_t bit[6] = {0,0,0,0,0,0};    
388     bit[0] = status & AliESDtrack::kTPCin;
389     bit[1] = status & AliESDtrack::kTPCout;
390     bit[2] = (status & AliESDtrack::kTPCout) && !(status & AliESDtrack::kTRDout);
391     bit[3] = status & AliESDtrack::kTRDout;
392     bit[4] = status & AliESDtrack::kTRDrefit;
393     bit[5] = (status & AliESDtrack::kTRDout) && !(status & AliESDtrack::kTRDrefit);
394
395     // transverse momentum
396     //const Double_t *val = paramOut->GetParameter(); // parameters at the Outer plane
397     Double_t pt = paramOut->Pt(); //1./TMath::Abs(val[4]);
398
399     for(Int_t b=0; b<knbits; b++) {
400       if (bit[b]) {
401         GetESDsData(2*b+3)->Fill(pt); 
402         GetESDsData(2*b+4)->Fill(extZ);
403       }
404     }
405
406     // clusters
407     for(Int_t b=0; b<3; b++) 
408       if (bit[3+b]) GetESDsData(b+15)->Fill(track->GetTRDncls());
409
410     // refitted only
411     if (!bit[4]) continue;
412
413     //fQuality->Fill(track->GetTRDQuality());
414     //fBudget->Fill(track->GetTRDBudget());
415     //fSignal->Fill(track->GetTRDsignal());
416         
417     GetESDsData(18)->Fill(track->GetP(), track->GetTRDsignal());
418
419     /*
420     // PID only
421     if (status & AliESDtrack::kTRDpid) {
422
423       for(Int_t l=0; l<6; l++) fTime->Fill(track->GetTRDTimBin(l));
424
425       // fill pid histograms
426       Double_t trdr0 = 0; //, tpcr0 = 0;
427       Int_t trdBestPid = 5; //, tpcBestPid = 5;  // charged
428       const Double_t kminPidValue = 0.9;
429
430       //Double_t pp[5];
431       //track->GetTPCpid(pp); // ESD inconsequence
432
433       for(Int_t pid=0; pid<5; pid++) {
434         
435         trdr0 += track->GetTRDpid(pid);
436         //tpcr0 += pp[pid];
437         
438         fTrdPID[pid]->Fill(track->GetTRDpid(pid));
439         //fTpcPID[pid]->Fill(pp[pid]);
440         
441         if (track->GetTRDpid(pid) > kminPidValue) trdBestPid = pid;
442         //if (pp[pid] > kminPidValue) tpcBestPid = pid;
443       }
444
445       fTrdPID[5]->Fill(trdr0); // check unitarity
446       fTrdSigMomPID[trdBestPid]->Fill(track->GetP(), track->GetTRDsignal());
447
448       //fTpcPID[5]->Fill(tpcr0); // check unitarity
449       //fTpcSigMomPID[tpcBestPid]->Fill(track->GetP(), track->GetTPCsignal());
450     }
451     */
452
453   }
454
455 }
456
457 //______________________________________________________________________________
458 Int_t AliTRDQADataMaker::GetSector(const Double_t alpha) const 
459 {
460   //
461   // Gets the sector number 
462   //
463
464   Double_t size = TMath::DegToRad() * 20.; // shall use TRDgeo
465   Int_t sector = (Int_t)((alpha + TMath::Pi())/size);
466   return sector;
467
468 }
469
470 //______________________________________________________________________________
471 Double_t AliTRDQADataMaker::GetExtZ(const AliExternalTrackParam *in) const 
472 {
473   //
474   // Returns the Z position at the entry to TRD
475   // using parameters from the TPC in
476   //
477
478   const Double_t kX0 = 300;
479
480   Double_t x = in->GetX();
481   const Double_t *par = in->GetParameter();
482   Double_t theta = par[3];
483   Double_t z = in->GetZ();
484
485   Double_t zz = z + (kX0-x) * TMath::Tan(theta);
486   return zz;
487
488 }
489
490 //____________________________________________________________________________
491 void AliTRDQADataMaker::MakeHits(TClonesArray * hits)
492 {
493   //
494   // Make QA data from Hits
495   //
496
497   TIter next(hits); 
498   AliTRDhit * hit; 
499
500   while ( (hit = dynamic_cast<AliTRDhit *>(next())) ) {
501     GetHitsData(0)->Fill(hit->GetDetector());
502     Double_t q = TMath::Abs(hit->GetCharge());
503
504     if (hit->FromDrift()) GetHitsData(1)->Fill(q);
505     if (hit->FromAmplification()) GetHitsData(2)->Fill(q);
506     if (hit->FromTRphoton()) GetHitsData(3)->Fill(q);
507   }
508
509 }
510
511 //____________________________________________________________________________
512 void AliTRDQADataMaker::MakeHits(TTree * hitTree)
513 {
514   //
515   // Make QA data from Hits
516   //
517
518   if (!CheckPointer(hitTree, "TRD hits tree")) return;
519
520   TBranch *branch = hitTree->GetBranch("TRD");
521   if (!CheckPointer(branch, "TRD hits branch")) return;
522
523   Int_t nhits = (Int_t)(hitTree->GetTotBytes()/sizeof(AliTRDhit));
524   TClonesArray *hits = new TClonesArray("AliTRDhit", nhits+1000);
525   TClonesArray *tmp = new TClonesArray("AliTRDhit", 1000);
526   branch->SetAddress(&tmp);
527
528   Int_t index = 0;
529   Int_t nEntries = (Int_t)branch->GetEntries();
530   for(Int_t i = 0; i < nEntries; i++) {
531     branch->GetEntry(i);
532     Int_t nHits = (Int_t)tmp->GetEntries();
533     for(Int_t j=0; j<nHits; j++) {
534       AliTRDhit *hit = (AliTRDhit*)tmp->At(j);
535       new((*hits)[index++]) AliTRDhit(*hit);
536     }
537   }
538
539   tmp->Delete();
540   delete tmp;
541   MakeHits(hits);
542
543 }
544
545 //____________________________________________________________________________
546 void AliTRDQADataMaker::MakeDigits(TClonesArray * digits)
547 {
548   //
549   // Makes data from Digits
550   //
551
552   TIter next(digits) ; 
553   AliTRDdigit * digit ; 
554   while ( (digit = dynamic_cast<AliTRDdigit *>(next())) ) {
555     GetDigitsData(0)->Fill(digit->GetDetector());
556     GetDigitsData(1)->Fill(digit->GetTime());
557     GetDigitsData(2)->Fill(digit->GetAmp());
558   }
559
560 }
561
562 //____________________________________________________________________________
563 void AliTRDQADataMaker::MakeDigits(TTree * digits)
564 {
565   //
566   // Makes data from digits tree
567   //
568
569   AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager();
570   digitsManager->CreateArrays();
571   digitsManager->ReadDigits(digits);
572
573   for (Int_t i = 0; i < AliTRDgeometry::kNdet; i++) {
574
575     AliTRDdataArrayI *digitsIn = digitsManager->GetDigits(i);      
576
577     // This is to take care of switched off super modules
578     if (digitsIn->GetNtime() == 0) continue;
579
580     digitsIn->Expand();
581
582     //AliTRDSignalIndex* indexes = digitsManager->GetIndexes(i);
583     //if (indexes->IsAllocated() == kFALSE) digitsManager->BuildIndexes(i);
584
585     Int_t nRows = digitsIn->GetNrow();
586     Int_t nCols = digitsIn->GetNcol();
587     Int_t nTbins = digitsIn->GetNtime();
588
589     for(Int_t row = 0; row < nRows; row++) 
590       for(Int_t col = 0; col < nCols; col++) 
591         for(Int_t time = 0; time < nTbins; time++) {
592
593           Float_t signal = digitsIn->GetDataUnchecked(row,col,time);
594           GetDigitsData(0)->Fill(i);
595           GetDigitsData(1)->Fill(time);
596           GetDigitsData(2)->Fill(signal);
597         }
598
599     //delete digitsIn;
600   }
601
602   delete digitsManager;
603
604 }
605
606 //____________________________________________________________________________
607 void AliTRDQADataMaker::MakeSDigits(TClonesArray * sdigits)
608 {
609   //
610   // Makes data from Digits
611   //
612
613   TIter next(sdigits) ; 
614   AliTRDdigit * digit ; 
615   while ( (digit = dynamic_cast<AliTRDdigit *>(next())) ) {
616     GetDigitsData(0)->Fill(digit->GetDetector());
617     GetDigitsData(1)->Fill(digit->GetTime());
618     GetDigitsData(2)->Fill(digit->GetAmp());
619   }
620
621 }
622
623 //____________________________________________________________________________
624 void AliTRDQADataMaker::MakeSDigits(TTree * digits)
625 {
626   //
627   // Makes data from SDigits
628   //
629
630   AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager();
631   digitsManager->CreateArrays();
632   digitsManager->ReadDigits(digits);
633
634   for (Int_t i = 0; i < AliTRDgeometry::kNdet; i++) {
635
636     AliTRDdataArrayI *digitsIn = digitsManager->GetDigits(i);      
637
638     // This is to take care of switched off super modules
639     if (digitsIn->GetNtime() == 0) continue;
640
641     digitsIn->Expand();
642
643     //AliTRDSignalIndex* indexes = digitsManager->GetIndexes(i);
644     //if (indexes->IsAllocated() == kFALSE) digitsManager->BuildIndexes(i);
645
646     Int_t nRows = digitsIn->GetNrow();
647     Int_t nCols = digitsIn->GetNcol();
648     Int_t nTbins = digitsIn->GetNtime();
649
650     for(Int_t row = 0; row < nRows; row++) 
651       for(Int_t col = 0; col < nCols; col++) 
652         for(Int_t time = 0; time < nTbins; time++) {
653
654           Float_t signal = digitsIn->GetDataUnchecked(row,col,time);
655           if (signal <= 0) continue;
656           GetSDigitsData(0)->Fill(i);
657           GetSDigitsData(1)->Fill(time);
658           GetSDigitsData(2)->Fill(signal);
659         }
660
661     // delete digitsIn;
662   }
663
664   delete digitsManager;
665
666 }
667
668 //____________________________________________________________________________
669 void AliTRDQADataMaker::MakeRaws(AliRawReader* rawReader)
670 {
671   //
672   // Makes QA data from raw data
673   //
674
675   // 157
676   // T9 -- T10
677
678   //const Int_t kSM = 18;
679   //const Int_t kROC = 30;
680   const Int_t kROB = 8;
681   //const Int_t kLayer = 6;
682   //const Int_t kStack = 5;
683   const Int_t kMCM = 16;
684   //  const Int_t kADC = 22;
685
686   //<<<<<<< AliTRDQADataMaker.cxx
687   //AliTRDrawStreamTB *raw = new AliTRDrawStreamTB(rawReader);
688   //raw->SetRawVersion(3);
689   //raw->Init();
690   //=======
691   AliTRDRawStreamV2 *raw = new AliTRDRawStreamV2(rawReader);
692   raw->SetRawVersion(3);
693   raw->Init();
694   //>>>>>>> 1.12
695
696   while (raw->Next()) {
697
698     GetRawsData(0)->Fill(raw->GetDet());
699
700     // possibly needs changes with the new reader !!
701     Int_t *sig = raw->GetSignals();
702     for(Int_t i=0; i<3; i++) GetRawsData(1)->Fill(sig[i]);
703     // ---
704
705     GetRawsData(2)->Fill(raw->GetTimeBin());
706
707     // calculate the index;
708     Int_t sm = raw->GetSM();
709     Int_t roc = raw->GetROC();
710     Int_t rob = raw->GetROB();
711     Int_t mcm = raw->GetMCM();
712     //Int_t adc = raw->GetADC();
713
714     //Int_t index = roc * (kROB*kMCM*kADC) + rob * (kMCM*kADC) + mcm * kADC + adc;
715     Int_t  index = roc * (kROB*kMCM) + rob * kMCM + mcm;
716     GetRawsData(3)->Fill(sm);
717     GetRawsData(4+sm)->Fill(index);
718   }
719
720   delete raw;
721
722 }
723
724 //____________________________________________________________________________
725 void AliTRDQADataMaker::MakeRecPoints(TTree * clustersTree)
726 {
727   //  
728   // Makes data from RecPoints
729   // 
730
731   Int_t nsize = Int_t(clustersTree->GetTotBytes() / (sizeof(AliTRDcluster))); 
732   TObjArray *clusterArray = new TObjArray(nsize+1000); 
733
734   TBranch *branch = clustersTree->GetBranch("TRDcluster");
735   if (!branch) {
736     AliError("Can't get the branch !");
737     return;
738   }
739   branch->SetAddress(&clusterArray); 
740
741   // Loop through all entries in the tree
742   Int_t nEntries   = (Int_t) clustersTree->GetEntries();
743   Int_t nbytes     = 0;
744   AliTRDcluster *c = 0;
745   Int_t nDet[540];
746   for (Int_t i=0; i<540; i++) nDet[i] = 0;
747
748   for (Int_t iEntry = 0; iEntry < nEntries; iEntry++) {    
749
750     // Import the tree
751     nbytes += clustersTree->GetEvent(iEntry);  
752
753     // Get the number of points in the detector
754     Int_t nCluster = clusterArray->GetEntriesFast();  
755
756     // Loop through all TRD digits
757     for (Int_t iCluster = 0; iCluster < nCluster; iCluster++) { 
758       c = (AliTRDcluster *) clusterArray->UncheckedAt(iCluster);
759
760       Int_t iDet = c->GetDetector();
761       nDet[iDet]++;
762       GetRecPointsData(0)->Fill(iDet);
763       GetRecPointsData(1)->Fill(iDet, c->GetQ());
764       GetRecPointsData(2)->Fill(c->GetNPads());
765       if (c->GetNPads() < 6)
766         GetRecPointsData(1+c->GetNPads())->Fill(c->GetCenter());
767
768       //if (c->GetPadTime() < 5)
769       ((TH2D*)GetRecPointsData(7))->Fill(c->GetPadRow(), c->GetPadCol());
770       GetRecPointsData(8)->Fill(c->GetPadTime());
771
772       ((TH3D*)GetRecPointsData(10))->Fill(iDet, c->GetPadTime(), c->GetQ());
773
774       // PRF for 2pad
775       //if (c->GetNPads() == 2) {
776       Short_t *sig = c->GetSignals();
777       Double_t frac = -10;
778
779       if (sig[0] == 0 && sig[1] == 0 && sig[2] == 0 && sig[5] == 0 && sig[6] == 0) 
780         frac = 1. * sig[4] / (sig[3] + sig[4]);
781
782       if (sig[0] == 0 && sig[1] == 0 && sig[4] == 0 && sig[5] == 0 && sig[6] == 0)
783         frac = -1. * sig[2] / (sig[2] + sig[3]);
784
785       if (frac > -10)  ((TProfile*)GetRecPointsData(11))->Fill(c->GetCenter(), frac);
786         
787       //}
788     }
789   }
790
791   for(Int_t i=0; i<540; i++) 
792     if (nDet[i] > 0) GetRecPointsData(9)->Fill(nDet[i]);
793
794   delete clusterArray;
795
796 }
797
798 //____________________________________________________________________________ 
799 void AliTRDQADataMaker::StartOfDetectorCycle()
800 {
801   //
802   // Detector specific actions at start of cycle
803   //
804
805 }
806
807 //__________________________________________________________________________
808 Int_t AliTRDQADataMaker::CheckPointer(TObject *obj, const char *name) 
809 {
810   //
811   // Checks initialization of pointers
812   //
813
814   if (!obj) AliWarning(Form("null pointer: %s", name));
815   return !!obj;
816
817 }