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