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