TPC/AliTPCdataQA.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
  17 /* $Id$ */
  18
  19 /*
  20   June 2010
  21
  22   This update should solve two problems mainly:
  23   * The vs event histograms have been limited to a fixed size for the
  24   DQM. The 500k seemed to be a big size but is no longer so, so we
  25   need to dynamically expand the range. The non-trivial point is that
  26   we also have to do it for the copy owned by AliTPCQADataMakerRec.
  27   * The amoreGui now remembers the x-range of the first visualization so
  28   the trick of setting the relevant event range as the histogram is
  29   filled no longer works.
  30
  31   The fix is a bit crude but avoids creating a new histogram. Instead
  32   the range is expanded (max events and events per bin is doubled) but
  33   the number of bins is kept constant! In this way we can change just
  34   double the max of the X-axis of the hist and rebin the data. The
  35   same can easily be done for the copy owned by AliTPCQADataMakerRec.
  36
  37   CAUTION:
  38   If we change the number of bins we could crash the whole system
  39   because ROOT does not create space for extra bins! (but we do not do
  40   this). In that way it is a crude solution.
  41   The rebinning in the code only works for an even number of bins.
  42
  43   In addition to the above a bug in the reading of the config file was
  44   also found and corrected. fAdcMax was set instead of fEventsPerBin.
  45
  46   Finally cout was changes to AliInfo.
  47
  48   February 2008
  49
  50   The code has been heavily modified so that now the RAW data is
  51   "expanded" for each sector and stored in a big signal array. Then a
  52   simple version of the code in AliTPCclustererMI is used to identify
  53   the local maxima and these are then used for QA. This gives a better
  54   estimate of the charge (both max and total) and also limits the
  55   effect of noise.
  56
  57   Implementation:
  58
  59   In Update the RAW signals >= 3 ADC channels are stored in the arrays.
  60
  61   There are 3 arrays:
  62   Float_t** fAllBins       2d array [row][bin(pad, time)] ADC signal
  63   Int_t**   fAllSigBins    2d array [row][signal#] bin(with signal)
  64   Int_t*    fAllNSigBins;  1d array [row] Nsignals
  65
  66   This is done sector by sector.
  67
  68   When data from a new sector is encountered, the method
  69   FindLocalMaxima is called on the data from the previous sector, and
  70   the calibration/data objects are updated with the "cluster"
  71   info. Finally the arrays are cleared.
  72
  73   The requirements for a local maxima is:
  74   Charge in bin is >= 5 ADC channels.
  75   Charge in bin is larger than all the 8 neighboring bins.
  76   At least one of the two pad neighbors has a signal.
  77   At least one of the two time neighbors has a signal.
  78
  79   Before accessing the data it is expected that the Analyse method is
  80   called. This normalizes some of the data objects to per event or per
  81   cluster.
  82   If more data is passed to the class after Analyse has been called
  83   the normalization is reversed and Analyse has to be called again.
  84 */
  85
  86
  87 //Root includes
  88 #include <TH1F.h>
  89 #include <TH2F.h>
  90 #include <TString.h>
  91 #include <TMath.h>
  92 #include <TDirectory.h>
  93 #include <TFile.h>
  94 #include <TError.h>
  95 #include <TMap.h>
  96 #include <TProfile.h>
  97 //AliRoot includes
  98 #include "AliRawReader.h"
  99 #include "AliRawReaderRoot.h"
 100 #include "AliRawReaderDate.h"
 101 #include "AliTPCRawStream.h"
 102 #include "AliTPCRawStreamV3.h"
 103 #include "AliTPCCalROC.h"
 104 #include "AliTPCROC.h"
 105 #include "AliMathBase.h"
 106 #include "TTreeStream.h"
 107 #include "AliTPCRawStreamFast.h"
 108
 109 //date
 110 #include "event.h"
 111 #include "AliTPCCalPad.h"
 112 #include "AliTPCPreprocessorOnline.h"
 113
 114 //header file
 115 #include "AliTPCdataQA.h"
 116 #include "AliLog.h"
 117
 118 ClassImp(AliTPCdataQA)
 119
 120 AliTPCdataQA::AliTPCdataQA() : /*FOLD00*/
 121   fFirstTimeBin(60),
 122   fLastTimeBin(1000),
 123   fAdcMin(1),
 124   fAdcMax(100),
 125   fMapping(NULL),
 126   fPedestal(0),
 127   fNoise(0),
 128   fNLocalMaxima(0),
 129   fMaxCharge(0),
 130   fMeanCharge(0),
 131   fNoThreshold(0),
 132   fNTimeBins(0),
 133   fNPads(0),
 134   fTimePosition(0),
 135   fOverThreshold10(0),
 136   fOverThreshold20(0),
 137   fOverThreshold30(0),
 138   fHistQVsTimeSideA(0),
 139   fHistQVsTimeSideC(0),
 140   fHistQMaxVsTimeSideA(0),
 141   fHistQMaxVsTimeSideC(0),
 142   fHistOccupancyVsEvent(0),
 143   fHistNclustersVsEvent(0),
 144   fEventCounter(0),
 145   fIsAnalysed(kFALSE),
 146   fMaxEvents(500000),           // Max events for event histograms
 147   fEventsPerBin(1000),          // Events per bin for event histograms
 148   fSignalCounter(0),            // Signal counter
 149   fClusterCounter(0),           // Cluster counter
 150   fAllBins(0),
 151   fAllSigBins(0),
 152   fAllNSigBins(0),
 153   fRowsMax(0),
 154   fPadsMax(0),
 155   fTimeBinsMax(0)
 156 {
 157   //
 158   // default constructor
 159   //
 160 }
 161
 162 //_____________________________________________________________________
 163 AliTPCdataQA::AliTPCdataQA(AliRecoParam::EventSpecie_t es) :
 164 fFirstTimeBin(60),
 165 fLastTimeBin(1000),
 166 fAdcMin(1),
 167 fAdcMax(100),
 168 fMapping(NULL),
 169 fPedestal(0),
 170 fNoise(0),
 171 fNLocalMaxima(0),
 172 fMaxCharge(0),
 173 fMeanCharge(0),
 174 fNoThreshold(0),
 175 fNTimeBins(0),
 176 fNPads(0),
 177 fTimePosition(0),
 178 fOverThreshold10(0),
 179 fOverThreshold20(0),
 180 fOverThreshold30(0),
 181 fHistQVsTimeSideA(0),
 182 fHistQVsTimeSideC(0),
 183 fHistQMaxVsTimeSideA(0),
 184 fHistQMaxVsTimeSideC(0),
 185 fHistOccupancyVsEvent(0),
 186 fHistNclustersVsEvent(0),
 187 fEventCounter(0),
 188 fIsAnalysed(kFALSE),
 189 fMaxEvents(500000),
 190 fEventsPerBin(1000),
 191 fSignalCounter(0),
 192 fClusterCounter(0),
 193 fAllBins(0),
 194 fAllSigBins(0),
 195 fAllNSigBins(0),
 196 fRowsMax(0),
 197 fPadsMax(0),
 198 fTimeBinsMax(0)
 199 {
 200 // ctor creating the histogram
 201   char *  name = Form("TPCRAW_%s", AliRecoParam::GetEventSpecieName(es)) ;
 202   TH1F(name, name,100,0,100) ;
 203 }
 204
 205 //_____________________________________________________________________
 206 AliTPCdataQA::AliTPCdataQA(const AliTPCdataQA &ped) : /*FOLD00*/
 207   TH1F(ped),
 208   fFirstTimeBin(ped.GetFirstTimeBin()),
 209   fLastTimeBin(ped.GetLastTimeBin()),
 210   fAdcMin(ped.GetAdcMin()),
 211   fAdcMax(ped.GetAdcMax()),
 212   fMapping(NULL),
 213   fPedestal(0),
 214   fNoise(0),
 215   fNLocalMaxima(0),
 216   fMaxCharge(0),
 217   fMeanCharge(0),
 218   fNoThreshold(0),
 219   fNTimeBins(0),
 220   fNPads(0),
 221   fTimePosition(0),
 222   fOverThreshold10(0),
 223   fOverThreshold20(0),
 224   fOverThreshold30(0),
 225   fHistQVsTimeSideA(0),
 226   fHistQVsTimeSideC(0),
 227   fHistQMaxVsTimeSideA(0),
 228   fHistQMaxVsTimeSideC(0),
 229   fHistOccupancyVsEvent(0),
 230   fHistNclustersVsEvent(0),
 231   fEventCounter(ped.GetEventCounter()),
 232   fIsAnalysed(ped.GetIsAnalysed()),
 233   fMaxEvents(ped.GetMaxEvents()),
 234   fEventsPerBin(ped.GetEventsPerBin()),
 235   fSignalCounter(ped.GetSignalCounter()),
 236   fClusterCounter(ped.GetClusterCounter()),
 237   fAllBins(0),
 238   fAllSigBins(0),
 239   fAllNSigBins(0),
 240   fRowsMax(0),
 241   fPadsMax(0),
 242   fTimeBinsMax(0)
 243 {
 244   //
 245   // copy constructor
 246   //
 247   if(ped.GetNLocalMaxima())
 248     fNLocalMaxima  = new AliTPCCalPad(*ped.GetNLocalMaxima());
 249   if(ped.GetMaxCharge())
 250     fMaxCharge      = new AliTPCCalPad(*ped.GetMaxCharge());
 251   if(ped.GetMeanCharge())
 252     fMeanCharge     = new AliTPCCalPad(*ped.GetMeanCharge());
 253   if(ped.GetNoThreshold())
 254     fNoThreshold  = new AliTPCCalPad(*ped.GetNoThreshold());
 255   if(ped.GetNTimeBins())
 256     fNTimeBins  = new AliTPCCalPad(*ped.GetNTimeBins());
 257   if(ped.GetNPads())
 258     fNPads  = new AliTPCCalPad(*ped.GetNPads());
 259   if(ped.GetTimePosition())
 260     fTimePosition  = new AliTPCCalPad(*ped.GetTimePosition());
 261   if(ped.GetOverThreshold10())
 262     fOverThreshold10  = new AliTPCCalPad(*ped.GetOverThreshold10());
 263   if(ped.GetOverThreshold20())
 264     fOverThreshold20  = new AliTPCCalPad(*ped.GetOverThreshold20());
 265   if(ped.GetOverThreshold30())
 266     fOverThreshold30  = new AliTPCCalPad(*ped.GetOverThreshold30());
 267   if(ped.GetHistQVsTimeSideA()) {
 268     fHistQVsTimeSideA = new TProfile(*ped.GetHistQVsTimeSideA());
 269     fHistQVsTimeSideA->SetDirectory(0);
 270   }
 271   if(ped.GetHistQVsTimeSideC()) {
 272     fHistQVsTimeSideC = new TProfile(*ped.GetHistQVsTimeSideC());
 273     fHistQVsTimeSideC->SetDirectory(0);
 274   }
 275   if(ped.GetHistQMaxVsTimeSideA()) {
 276     fHistQMaxVsTimeSideA = new TProfile(*ped.GetHistQMaxVsTimeSideA());
 277     fHistQMaxVsTimeSideA->SetDirectory(0);
 278   }
 279   if(ped.GetHistQMaxVsTimeSideC()) {
 280     fHistQMaxVsTimeSideC = new TProfile(*ped.GetHistQMaxVsTimeSideC());
 281     fHistQMaxVsTimeSideC->SetDirectory(0);
 282   }
 283   if(ped.GetHistOccupancyVsEventConst()) {
 284     fHistOccupancyVsEvent  = new TH1F(*ped.GetHistOccupancyVsEventConst());
 285     fHistOccupancyVsEvent->SetDirectory(0);
 286   }
 287   if(ped.GetHistNclustersVsEventConst()) {
 288     fHistNclustersVsEvent  = new TH1F(*ped.GetHistNclustersVsEventConst());
 289     fHistNclustersVsEvent->SetDirectory(0);
 290   }
 291 }
 292
 293 //_____________________________________________________________________
 294 AliTPCdataQA::AliTPCdataQA(const TMap *config) : /*FOLD00*/
 295   TH1F("TPCRAW","TPCRAW",100,0,100),
 296   fFirstTimeBin(60),
 297   fLastTimeBin(1000),
 298   fAdcMin(1),
 299   fAdcMax(100),
 300   fMapping(NULL),
 301   fPedestal(0),
 302   fNoise(0),
 303   fNLocalMaxima(0),
 304   fMaxCharge(0),
 305   fMeanCharge(0),
 306   fNoThreshold(0),
 307   fNTimeBins(0),
 308   fNPads(0),
 309   fTimePosition(0),
 310   fOverThreshold10(0),
 311   fOverThreshold20(0),
 312   fOverThreshold30(0),
 313   fHistQVsTimeSideA(0),
 314   fHistQVsTimeSideC(0),
 315   fHistQMaxVsTimeSideA(0),
 316   fHistQMaxVsTimeSideC(0),
 317   fHistOccupancyVsEvent(0),
 318   fHistNclustersVsEvent(0),
 319   fEventCounter(0),
 320   fIsAnalysed(kFALSE),
 321   fMaxEvents(500000),
 322   fEventsPerBin(1000),
 323   fSignalCounter(0),
 324   fClusterCounter(0),
 325   fAllBins(0),
 326   fAllSigBins(0),
 327   fAllNSigBins(0),
 328   fRowsMax(0),
 329   fPadsMax(0),
 330   fTimeBinsMax(0)
 331 {
 332   //
 333   // default constructor
 334   //
 335   if (config->GetValue("FirstTimeBin")) fFirstTimeBin = ((TObjString*)config->GetValue("FirstTimeBin"))->GetString().Atoi();
 336   if (config->GetValue("LastTimeBin"))  fLastTimeBin = ((TObjString*)config->GetValue("LastTimeBin"))->GetString().Atoi();
 337   if (config->GetValue("AdcMin"))       fAdcMin = ((TObjString*)config->GetValue("AdcMin"))->GetString().Atoi();
 338   if (config->GetValue("AdcMax"))       fAdcMax = ((TObjString*)config->GetValue("AdcMax"))->GetString().Atoi();
 339   if (config->GetValue("MaxEvents"))    fMaxEvents = ((TObjString*)config->GetValue("MaxEvents"))->GetString().Atoi();
 340   if (config->GetValue("EventsPerBin")) fEventsPerBin = ((TObjString*)config->GetValue("EventsPerBin"))->GetString().Atoi();
 341 }
 342
 343 //_____________________________________________________________________
 344 AliTPCdataQA& AliTPCdataQA::operator = (const  AliTPCdataQA &source)
 345 {
 346   //
 347   // assignment operator
 348   //
 349   if (&source == this) return *this;
 350   new (this) AliTPCdataQA(source);
 351
 352   return *this;
 353 }
 354
 355
 356 //_____________________________________________________________________
 357 AliTPCdataQA::~AliTPCdataQA() /*FOLD00*/
 358 {
 359   //
 360   // destructor
 361   //
 362
 363   // do not delete fMapping, because we do not own it.
 364   // do not delete fMapping, because we do not own it.
 365   // do not delete fNoise and fPedestal, because we do not own them.
 366
 367   delete fNLocalMaxima;
 368   delete fMaxCharge;
 369   delete fMeanCharge;
 370   delete fNoThreshold;
 371   delete fNTimeBins;
 372   delete fNPads;
 373   delete fTimePosition;
 374   delete fOverThreshold10;
 375   delete fOverThreshold20;
 376   delete fOverThreshold30;
 377   delete fHistQVsTimeSideA;
 378   delete fHistQVsTimeSideC;
 379   delete fHistQMaxVsTimeSideA;
 380   delete fHistQMaxVsTimeSideC;
 381   delete fHistOccupancyVsEvent;
 382   delete fHistNclustersVsEvent;
 383
 384   for (Int_t iRow = 0; iRow < fRowsMax; iRow++) {
 385     delete [] fAllBins[iRow];
 386     delete [] fAllSigBins[iRow];
 387   }
 388   delete [] fAllBins;
 389   delete [] fAllSigBins;
 390   delete [] fAllNSigBins;
 391 }
 392
 393 //_____________________________________________________________________
 394 TH1F* AliTPCdataQA::GetHistOccupancyVsEvent()
 395 {
 396   //
 397   // Create Occupancy vs event histogram
 398   // (we create this histogram differently then the other histograms
 399   //  because this we want to be able to access and copy
 400   //  from AliTPCQAMakerRec before it normally would be created)
 401   //
 402   if(!fHistOccupancyVsEvent) {
 403
 404     Int_t nBins = fMaxEvents/fEventsPerBin;
 405     fHistOccupancyVsEvent = new TH1F("hOccupancyVsEvent", "Occupancy vs event number (~time); Event number; Occupancy", nBins, 0, nBins*fEventsPerBin);
 406     fHistOccupancyVsEvent->SetDirectory(0);
 407   }
 408
 409   return fHistOccupancyVsEvent;
 410 }
 411
 412 //_____________________________________________________________________
 413 TH1F* AliTPCdataQA::GetHistNclustersVsEvent()
 414 {
 415   //
 416   // Create Nclusters vs event histogram
 417   // (we create this histogram differently then the other histograms
 418   //  because this we want to be able to access and copy
 419   //  from AliTPCQAMakerRec before it normally would be created)
 420   //
 421   if(!fHistNclustersVsEvent) {
 422
 423     Int_t nBins = fMaxEvents/fEventsPerBin;
 424     fHistNclustersVsEvent = new TH1F("hNclustersVsEvent", "Nclusters vs event number (~time); Event number; Nclusters per event", nBins, 0, nBins*fEventsPerBin);
 425     fHistNclustersVsEvent->SetDirectory(0);
 426   }
 427
 428   return fHistNclustersVsEvent;
 429 }
 430
 431 //_____________________________________________________________________
 432 void AliTPCdataQA::UpdateEventHistograms()
 433 {
 434   // Update histograms that display occupancy and
 435   // number of clusters as a function of number of
 436   // events
 437   if (!fHistOccupancyVsEvent)
 438     GetHistOccupancyVsEvent();
 439   if (!fHistNclustersVsEvent)
 440     GetHistNclustersVsEvent();
 441
 442   if(fEventCounter > fMaxEvents) {
 443
 444     // we have to expand the histogram to handle the larger number of
 445     // events. The way it is done now is to double the range and the
 446     // number of events per bin (so the number of histogram bins stays
 447     // constant)
 448     fEventsPerBin *= 2;
 449     fMaxEvents *= 2;
 450
 451     // Change histogram limits
 452     const Int_t nBins = fHistOccupancyVsEvent->GetXaxis()->GetNbins();
 453     fHistOccupancyVsEvent->GetXaxis()->Set(nBins, fHistOccupancyVsEvent->GetXaxis()->GetNbins(), fMaxEvents);
 454     fHistNclustersVsEvent->GetXaxis()->Set(nBins, fHistNclustersVsEvent->GetXaxis()->GetNbins(), fMaxEvents);
 455
 456     // Rebin the histogram
 457     for(Int_t bin = 1; bin <= nBins; bin+=2) {
 458
 459       Int_t newBin = TMath::Nint(Float_t(bin+1)/2.0);
 460       Float_t newContent = (fHistOccupancyVsEvent->GetBinContent(bin)+
 461                             fHistOccupancyVsEvent->GetBinContent(bin+1))/2.0;
 462       fHistOccupancyVsEvent->SetBinContent(newBin, newContent);
 463
 464       newContent = (fHistNclustersVsEvent->GetBinContent(bin)+
 465                     fHistNclustersVsEvent->GetBinContent(bin+1))/2.0;
 466       fHistNclustersVsEvent->SetBinContent(newBin, newContent);
 467     }
 468
 469     // Set the remaining bins to 0
 470     Int_t lastHalf = nBins/2 +1;
 471     for(Int_t bin = lastHalf; bin <= nBins; bin++) {
 472
 473       fHistOccupancyVsEvent->SetBinContent(bin, 0);
 474       fHistNclustersVsEvent->SetBinContent(bin, 0);
 475     }
 476
 477     // In this case we should nut update but wait untill the new
 478     // number of events per bin is reached!
 479     return;
 480   }
 481
 482   const Int_t bin = TMath::Nint(Float_t(fEventCounter)/fEventsPerBin);
 483
 484   Float_t averageOccupancy =
 485     Float_t(fSignalCounter)/fEventsPerBin/(fLastTimeBin - fFirstTimeBin +1.0)
 486     / 570132.0; // 570,132 is number of pads
 487   fHistOccupancyVsEvent->SetBinContent(bin, averageOccupancy);
 488   fSignalCounter = 0;
 489
 490   Float_t averageNclusters =
 491     Float_t(fClusterCounter)/fEventsPerBin;
 492   fHistNclustersVsEvent->SetBinContent(bin, averageNclusters);
 493   fClusterCounter = 0;
 494 }
 495
 496 //_____________________________________________________________________
 497 Bool_t AliTPCdataQA::ProcessEvent(AliTPCRawStreamV3 *const rawStreamV3)
 498 {
 499   //
 500   // Event Processing loop - AliTPCRawStreamV3
 501   //
 502   Bool_t withInput = kFALSE;
 503   Int_t nSignals = 0;
 504   Int_t lastSector = -1;
 505
 506   while ( rawStreamV3->NextDDL() ){
 507
 508     while ( rawStreamV3->NextChannel() ){
 509
 510       Int_t iSector = rawStreamV3->GetSector(); //  current sector
 511       Int_t iRow    = rawStreamV3->GetRow();    //  current row
 512       Int_t iPad    = rawStreamV3->GetPad();    //  current pad
 513       if (iRow<0 || iPad<0) continue;
 514       // Call local maxima finder if the data is in a new sector
 515       if(iSector != lastSector) {
 516
 517         if(nSignals>0)
 518           FindLocalMaxima(lastSector);
 519
 520         CleanArrays();
 521         lastSector = iSector;
 522         nSignals = 0;
 523       }
 524
 525       while ( rawStreamV3->NextBunch() ){
 526
 527         Int_t  startTbin    = (Int_t)rawStreamV3->GetStartTimeBin();
 528         Int_t  bunchlength  = (Int_t)rawStreamV3->GetBunchLength();
 529         const UShort_t *sig = rawStreamV3->GetSignals();
 530
 531         for (Int_t iTimeBin = 0; iTimeBin<bunchlength; iTimeBin++){
 532           Float_t signal=(Float_t)sig[iTimeBin];
 533           nSignals += Update(iSector,iRow,iPad,startTbin--,signal);
 534           withInput = kTRUE;
 535         }
 536       }
 537     }
 538   }
 539
 540   if (lastSector>=0&&nSignals>0)
 541     FindLocalMaxima(lastSector);
 542
 543   return withInput;
 544 }
 545
 546 //_____________________________________________________________________
 547 Bool_t AliTPCdataQA::ProcessEvent(AliRawReader *const rawReader)
 548 {
 549   //
 550   //  Event processing loop - AliRawReader
 551   //
 552   AliTPCRawStreamV3 rawStreamV3(rawReader, (AliAltroMapping**)fMapping);
 553   Bool_t res=ProcessEvent(&rawStreamV3);
 554   if(res) {
 555     fEventCounter++; // only increment event counter if there is TPC data
 556
 557     if(fEventCounter%fEventsPerBin==0)
 558       UpdateEventHistograms();
 559   }
 560   return res;
 561 }
 562
 563 //_____________________________________________________________________
 564 Bool_t AliTPCdataQA::ProcessEventFast(AliTPCRawStreamFast *const rawStreamFast)
 565 {
 566   //
 567   // Event Processing loop - AliTPCRawStream
 568   //
 569   Bool_t withInput = kFALSE;
 570   Int_t nSignals = 0;
 571   Int_t lastSector = -1;
 572
 573   while ( rawStreamFast->NextDDL() ){
 574     while ( rawStreamFast->NextChannel() ){
 575
 576       Int_t iSector  = rawStreamFast->GetSector(); //  current sector
 577       Int_t iRow     = rawStreamFast->GetRow();    //  current row
 578       Int_t iPad     = rawStreamFast->GetPad();    //  current pad
 579   // Call local maxima finder if the data is in a new sector
 580       if(iSector != lastSector) {
 581
 582         if(nSignals>0)
 583           FindLocalMaxima(lastSector);
 584
 585         CleanArrays();
 586         lastSector = iSector;
 587         nSignals = 0;
 588       }
 589
 590       while ( rawStreamFast->NextBunch() ){
 591         Int_t startTbin = (Int_t)rawStreamFast->GetStartTimeBin();
 592         Int_t endTbin = (Int_t)rawStreamFast->GetEndTimeBin();
 593
 594         for (Int_t iTimeBin = startTbin; iTimeBin < endTbin; iTimeBin++){
 595           Float_t signal = rawStreamFast->GetSignals()[iTimeBin-startTbin];
 596           nSignals += Update(iSector,iRow,iPad,iTimeBin+1,signal);
 597           withInput = kTRUE;
 598         }
 599       }
 600     }
 601   }
 602
 603   return withInput;
 604 }
 605 //_____________________________________________________________________
 606 Bool_t AliTPCdataQA::ProcessEventFast(AliRawReader *const rawReader)
 607 {
 608   //
 609   //  Event processing loop - AliRawReader
 610   //
 611   AliTPCRawStreamFast rawStreamFast(rawReader, (AliAltroMapping**)fMapping);
 612   Bool_t res=ProcessEventFast(&rawStreamFast);
 613   if(res)
 614     fEventCounter++; // only increment event counter if there is TPC data
 615                      // otherwise Analyse (called in QA) fails
 616
 617   return res;
 618 }
 619
 620 //_____________________________________________________________________
 621 Bool_t AliTPCdataQA::ProcessEvent(AliTPCRawStream *const rawStream)
 622 {
 623   //
 624   // Event Processing loop - AliTPCRawStream
 625   //
 626
 627   Bool_t withInput = kFALSE;
 628   Int_t nSignals = 0;
 629   Int_t lastSector = -1;
 630
 631   while (rawStream->Next()) {
 632
 633     Int_t iSector  = rawStream->GetSector();      //  current ROC
 634     Int_t iRow     = rawStream->GetRow();         //  current row
 635     Int_t iPad     = rawStream->GetPad();         //  current pad
 636     Int_t iTimeBin = rawStream->GetTime();        //  current time bin
 637     Float_t signal = rawStream->GetSignal();      //  current ADC signal
 638
 639     // Call local maxima finder if the data is in a new sector
 640     if(iSector != lastSector) {
 641
 642       if(nSignals>0)
 643         FindLocalMaxima(lastSector);
 644
 645       CleanArrays();
 646       lastSector = iSector;
 647       nSignals = 0;
 648     }
 649
 650     // Sometimes iRow==-1 if there is problems to read the data
 651     if(iRow>=0) {
 652       nSignals += Update(iSector,iRow,iPad,iTimeBin,signal);
 653       withInput = kTRUE;
 654     }
 655   }
 656
 657   if (lastSector>=0&&nSignals>0)
 658     FindLocalMaxima(lastSector);
 659
 660   return withInput;
 661 }
 662
 663
 664 //_____________________________________________________________________
 665 Bool_t AliTPCdataQA::ProcessEventOld(AliRawReader *const rawReader)
 666 {
 667   //
 668   //  Event processing loop - AliRawReader
 669   //
 670
 671   // if fMapping is NULL the rawstream will crate its own mapping
 672   AliTPCRawStream rawStream(rawReader, (AliAltroMapping**)fMapping);
 673   rawReader->Select("TPC");
 674   Bool_t res =  ProcessEvent(&rawStream);
 675
 676   if(res)
 677     fEventCounter++; // only increment event counter if there is TPC data
 678                      // otherwise Analyse (called in QA) fails
 679   return res;
 680 }
 681
 682
 683 //_____________________________________________________________________
 684 Bool_t AliTPCdataQA::ProcessEvent(eventHeaderStruct *const event)
 685 {
 686   //
 687   //  process date event
 688   //
 689
 690   AliRawReaderDate rawReader((void*)event);
 691   Bool_t result=ProcessEvent(&rawReader);
 692   return result;
 693 }
 694
 695
 696
 697 //_____________________________________________________________________
 698 void AliTPCdataQA::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/
 699 {
 700   //
 701   //  Write class to file
 702   //
 703
 704   TString sDir(dir);
 705   TString option;
 706
 707   if ( append )
 708     option = "update";
 709   else
 710     option = "recreate";
 711
 712   TDirectory *backup = gDirectory;
 713   TFile f(filename,option.Data());
 714   f.cd();
 715   if ( !sDir.IsNull() ){
 716     f.mkdir(sDir.Data());
 717     f.cd(sDir);
 718   }
 719   this->Write();
 720   f.Close();
 721
 722   if ( backup ) backup->cd();
 723 }
 724
 725
 726 //_____________________________________________________________________
 727 Int_t AliTPCdataQA::Update(const Int_t iSector, /*FOLD00*/
 728                            const Int_t iRow,
 729                            const Int_t iPad,
 730                            const Int_t iTimeBin,
 731                            Float_t signal)
 732 {
 733   //
 734   // Signal filling method
 735   //
 736
 737   //
 738   // Define the calibration objects the first time Update is called
 739   // NB! This has to be done first even if the data is rejected by the time
 740   // cut to make sure that the objects are available in Analyse
 741   //
 742   if (!fNLocalMaxima) fNLocalMaxima = new AliTPCCalPad("NLocalMaxima","NLocalMaxima");
 743   if (!fMaxCharge) fMaxCharge = new AliTPCCalPad("MaxCharge","MaxCharge");
 744   if (!fMeanCharge) fMeanCharge = new AliTPCCalPad("MeanCharge","MeanCharge");
 745   if (!fNoThreshold) fNoThreshold = new AliTPCCalPad("NoThreshold","NoThreshold");
 746   if (!fNTimeBins) fNTimeBins = new AliTPCCalPad("NTimeBins","NTimeBins");
 747   if (!fNPads) fNPads = new AliTPCCalPad("NPads","NPads");
 748   if (!fTimePosition) fTimePosition = new AliTPCCalPad("TimePosition","TimePosition");
 749   if (!fOverThreshold10) fOverThreshold10 = new AliTPCCalPad("OverThreshold10","OverThreshold10");
 750   if (!fOverThreshold20) fOverThreshold20 = new AliTPCCalPad("OverThreshold20","OverThreshold20");
 751   if (!fOverThreshold30) fOverThreshold30 = new AliTPCCalPad("OverThreshold30","OverThreshold30");
 752   if (!fHistQVsTimeSideA) {
 753     fHistQVsTimeSideA  = new TProfile("hQVsTimeSideA", "Q vs time (side A); Time [Timebin]; Q [ADC ch]", 100, 0, 1000);
 754     fHistQVsTimeSideA->SetDirectory(0);
 755   }
 756   if (!fHistQVsTimeSideC) {
 757     fHistQVsTimeSideC  = new TProfile("hQVsTimeSideC", "Q vs time (side C); Time [Timebin]; Q [ADC ch]", 100, 0, 1000);
 758     fHistQVsTimeSideC->SetDirectory(0);
 759   }
 760   if (!fHistQMaxVsTimeSideA) {
 761     fHistQMaxVsTimeSideA  = new TProfile("hQMaxVsTimeSideA", "Q_{MAX} vs time (side A); Time [Timebin]; Q_{MAX} [ADC ch]", 100, 0, 1000);
 762     fHistQMaxVsTimeSideA->SetDirectory(0);
 763   }
 764   if (!fHistQMaxVsTimeSideC) {
 765     fHistQMaxVsTimeSideC  = new TProfile("hQMaxVsTimeSideC", "Q_{MAX} vs time (side C); Time [Timebin]; Q_{MAX} [ADC ch]", 100, 0, 1000);
 766     fHistQMaxVsTimeSideC->SetDirectory(0);
 767   }
 768
 769   // Make the arrays for expanding the data
 770
 771   if (!fAllBins)
 772     MakeArrays();
 773
 774   //
 775   // If Analyse has been previously called we need now to denormalize the data
 776   // as more data is coming
 777   //
 778   if(fIsAnalysed == kTRUE) {
 779
 780     const Int_t nTimeBins = fLastTimeBin - fFirstTimeBin +1;
 781     const Float_t denormalization = Float_t(fEventCounter * nTimeBins);
 782     fNoThreshold->Multiply(denormalization);
 783
 784     fMeanCharge->Multiply(fNLocalMaxima);
 785     fMaxCharge->Multiply(fNLocalMaxima);
 786     fNTimeBins->Multiply(fNLocalMaxima);
 787     fNPads->Multiply(fNLocalMaxima);
 788     fTimePosition->Multiply(fNLocalMaxima);
 789     fIsAnalysed = kFALSE;
 790   }
 791
 792   //
 793   // TimeBin cut
 794   //
 795   if (iTimeBin<fFirstTimeBin) return 0;
 796   if (iTimeBin>fLastTimeBin) return 0;
 797
 798   // if pedestal calibrations are loaded subtract pedestals
 799   if(fPedestal) {
 800
 801     Float_t ped = fPedestal->GetCalROC(iSector)->GetValue(iRow, iPad);
 802     // Don't use data from pads where pedestals are abnormally small or large
 803     if(ped<10 || ped>90)
 804       return 0;
 805     signal -= ped;
 806   }
 807
 808   // In fNoThreshold we fill all data to estimate the ZS volume
 809   Float_t count = fNoThreshold->GetCalROC(iSector)->GetValue(iRow, iPad);
 810   fNoThreshold->GetCalROC(iSector)->SetValue(iRow, iPad,count+1);
 811
 812   // Require at least 3 ADC channels
 813   if (signal < 3.0)
 814     return 0;
 815
 816   // if noise calibrations are loaded require at least 3*sigmaNoise
 817   if(fNoise) {
 818
 819     Float_t noise = fNoise->GetCalROC(iSector)->GetValue(iRow, iPad);
 820
 821     if(signal < noise*3.0)
 822       return 0;
 823   }
 824
 825   //
 826   // This signal is ok and we store it in the cluster map
 827   //
 828
 829   SetExpandDigit(iRow, iPad, iTimeBin, signal);
 830
 831   fSignalCounter++;
 832
 833   return 1; // signal was accepted
 834 }
 835
 836 //_____________________________________________________________________
 837 void AliTPCdataQA::FindLocalMaxima(const Int_t iSector)
 838 {
 839   //
 840   // This method is called after the data from each sector has been
 841   // exapanded into an array
 842   // Loop over the signals and identify local maxima and fill the
 843   // calibration objects with the information
 844   //
 845
 846   Int_t nLocalMaxima = 0;
 847   const Int_t maxTimeBin = fTimeBinsMax+4; // Used to step between neighboring pads
 848                                            // Because we have tha pad-time data in a
 849                                            // 1d array
 850
 851   for (Int_t iRow = 0; iRow < fRowsMax; iRow++) {
 852
 853     Float_t* allBins = fAllBins[iRow];
 854     Int_t* sigBins   = fAllSigBins[iRow];
 855     const Int_t nSigBins   = fAllNSigBins[iRow];
 856
 857     for (Int_t iSig = 0; iSig < nSigBins; iSig++) {
 858
 859       Int_t bin  = sigBins[iSig];
 860       Float_t *b = &allBins[bin];
 861
 862       //
 863       // Now we check if this is a local maximum
 864       //
 865
 866       Float_t qMax = b[0];
 867
 868       // First check that the charge is bigger than the threshold
 869       if (qMax<5)
 870         continue;
 871
 872       // Require at least one neighboring pad with signal
 873       if (b[-maxTimeBin]+b[maxTimeBin]<=0) continue;
 874
 875       // Require at least one neighboring time bin with signal
 876       if (b[-1]+b[1]<=0) continue;
 877
 878       //
 879       // Check that this is a local maximum
 880       // Note that the checking is done so that if 2 charges has the same
 881       // qMax then only 1 cluster is generated
 882       // (that is why there is BOTH > and >=)
 883       //
 884       if (b[-maxTimeBin]   >= qMax) continue;
 885       if (b[-1  ]          >= qMax) continue;
 886       if (b[+maxTimeBin]   > qMax)  continue;
 887       if (b[+1  ]          > qMax)  continue;
 888       if (b[-maxTimeBin-1] >= qMax) continue;
 889       if (b[+maxTimeBin-1] >= qMax) continue;
 890       if (b[+maxTimeBin+1] > qMax)  continue;
 891       if (b[-maxTimeBin+1] >= qMax) continue;
 892
 893       //
 894       // Now we accept the local maximum and fill the calibration/data objects
 895       //
 896       nLocalMaxima++;
 897
 898       Int_t iPad, iTimeBin;
 899       GetPadAndTimeBin(bin, iPad, iTimeBin);
 900
 901       Float_t count = fNLocalMaxima->GetCalROC(iSector)->GetValue(iRow, iPad);
 902       fNLocalMaxima->GetCalROC(iSector)->SetValue(iRow, iPad, count+1);
 903
 904       count = fTimePosition->GetCalROC(iSector)->GetValue(iRow, iPad);
 905       fTimePosition->GetCalROC(iSector)->SetValue(iRow, iPad, count+iTimeBin);
 906
 907       Float_t charge = fMaxCharge->GetCalROC(iSector)->GetValue(iRow, iPad);
 908       fMaxCharge->GetCalROC(iSector)->SetValue(iRow, iPad, charge + qMax);
 909
 910       if(qMax>=10) {
 911         count = fOverThreshold10->GetCalROC(iSector)->GetValue(iRow, iPad);
 912         fOverThreshold10->GetCalROC(iSector)->SetValue(iRow, iPad, count+1);
 913       }
 914       if(qMax>=20) {
 915         count = fOverThreshold20->GetCalROC(iSector)->GetValue(iRow, iPad);
 916         fOverThreshold20->GetCalROC(iSector)->SetValue(iRow, iPad, count+1);
 917       }
 918       if(qMax>=30) {
 919         count = fOverThreshold30->GetCalROC(iSector)->GetValue(iRow, iPad);
 920         fOverThreshold30->GetCalROC(iSector)->SetValue(iRow, iPad, count+1);
 921       }
 922
 923       //
 924       // Calculate the total charge as the sum over the region:
 925       //
 926       //    o o o o o
 927       //    o i i i o
 928       //    o i C i o
 929       //    o i i i o
 930       //    o o o o o
 931       //
 932       // with qmax at the center C.
 933       //
 934       // The inner charge (i) we always add, but we only add the outer
 935       // charge (o) if the neighboring inner bin (i) has a signal.
 936       //
 937       Int_t minP = 0, maxP = 0, minT = 0, maxT = 0;
 938       Float_t qTot = qMax;
 939       for(Int_t i = -1; i<=1; i++) {
 940         for(Int_t j = -1; j<=1; j++) {
 941
 942           if(i==0 && j==0)
 943             continue;
 944
 945           Float_t charge1 = GetQ(b, i, j, maxTimeBin, minT, maxT, minP, maxP);
 946           qTot += charge1;
 947           if(charge1>0) {
 948             // see if the next neighbor is also above threshold
 949             if(i*j==0) {
 950               qTot += GetQ(b, 2*i, 2*j, maxTimeBin, minT, maxT, minP, maxP);
 951             } else {
 952               // we are in a diagonal corner
 953               qTot += GetQ(b,   i, 2*j, maxTimeBin, minT, maxT, minP, maxP);
 954               qTot += GetQ(b, 2*i,   j, maxTimeBin, minT, maxT, minP, maxP);
 955               qTot += GetQ(b, 2*i, 2*j, maxTimeBin, minT, maxT, minP, maxP);
 956             }
 957           }
 958         }
 959       }
 960
 961       charge = fMeanCharge->GetCalROC(iSector)->GetValue(iRow, iPad);
 962       fMeanCharge->GetCalROC(iSector)->SetValue(iRow, iPad, charge + qTot);
 963
 964       count = fNTimeBins->GetCalROC(iSector)->GetValue(iRow, iPad);
 965       fNTimeBins->GetCalROC(iSector)->SetValue(iRow, iPad, count + maxT-minT+1);
 966
 967       count = fNPads->GetCalROC(iSector)->GetValue(iRow, iPad);
 968       fNPads->GetCalROC(iSector)->SetValue(iRow, iPad, count + maxP-minP+1);
 969
 970       if((iSector%36)<18) { // A side
 971         fHistQVsTimeSideA->Fill(iTimeBin, qTot);
 972         fHistQMaxVsTimeSideA->Fill(iTimeBin, qMax);
 973       } else {
 974         fHistQVsTimeSideC->Fill(iTimeBin, qTot);
 975         fHistQMaxVsTimeSideC->Fill(iTimeBin, qMax);
 976       }
 977     } // end loop over signals
 978   } // end loop over rows
 979
 980   fClusterCounter += nLocalMaxima;
 981 }
 982
 983 //_____________________________________________________________________
 984 void AliTPCdataQA::Analyse()
 985 {
 986   //
 987   //  Calculate calibration constants
 988   //
 989
 990   AliInfo("Analyse called");
 991
 992   if(fIsAnalysed == kTRUE) {
 993
 994     AliInfo("No new data since Analyse was called last time");
 995     return;
 996   }
 997
 998   if(fEventCounter==0) {
 999
1000       AliInfo("EventCounter == 0, Cannot analyse");
1001     return;
1002   }
1003
1004   Int_t nTimeBins = fLastTimeBin - fFirstTimeBin +1;
1005   AliInfo(Form("EventCounter: %d , TimeBins: %d", fEventCounter, nTimeBins));
1006
1007   Float_t normalization = 1.0 / Float_t(fEventCounter * nTimeBins);
1008   fNoThreshold->Multiply(normalization);
1009
1010   fMeanCharge->Divide(fNLocalMaxima);
1011   fMaxCharge->Divide(fNLocalMaxima);
1012   fNTimeBins->Divide(fNLocalMaxima);
1013   fNPads->Divide(fNLocalMaxima);
1014   fTimePosition->Divide(fNLocalMaxima);
1015
1016   fIsAnalysed = kTRUE;
1017 }
1018
1019
1020 //_____________________________________________________________________
1021 void AliTPCdataQA::MakeTree(const char *fname) const {
1022   //
1023   // Export result to the tree -located in the file
1024   // This file can be analyzed using AliTPCCalibViewer
1025   //
1026   AliTPCPreprocessorOnline preprocesor;
1027
1028   if (fNLocalMaxima) preprocesor.AddComponent(fNLocalMaxima);
1029   if (fMaxCharge) preprocesor.AddComponent(fMaxCharge);
1030   if (fMeanCharge) preprocesor.AddComponent(fMeanCharge);
1031   if (fNoThreshold) preprocesor.AddComponent(fNoThreshold);
1032   if (fNTimeBins) preprocesor.AddComponent(fNTimeBins);
1033   if (fNPads) preprocesor.AddComponent(fNPads);
1034   if (fTimePosition) preprocesor.AddComponent(fTimePosition);
1035   if (fOverThreshold10) preprocesor.AddComponent(fOverThreshold10);
1036   if (fOverThreshold20) preprocesor.AddComponent(fOverThreshold20);
1037   if (fOverThreshold30) preprocesor.AddComponent(fOverThreshold30);
1038
1039   preprocesor.DumpToFile(fname);
1040 }
1041
1042
1043 //_____________________________________________________________________
1044 void AliTPCdataQA::MakeArrays(){
1045   //
1046   // The arrays for expanding the raw data are defined and
1047   // som parameters are intialised
1048   //
1049   AliTPCROC * roc = AliTPCROC::Instance();
1050   //
1051   // To make the array big enough for all sectors we take
1052   // the dimensions from the outer row of an OROC (the last sector)
1053   //
1054   fRowsMax     = roc->GetNRows(roc->GetNSector()-1);
1055   fPadsMax     = roc->GetNPads(roc->GetNSector()-1,fRowsMax-1);
1056   fTimeBinsMax = fLastTimeBin - fFirstTimeBin +1;
1057
1058   //
1059   // Since we have added 2 pads (TimeBins) before and after the real pads (TimeBins)
1060   // to make sure that we can always query the exanded table even when the
1061   // max is on the edge
1062   //
1063
1064
1065   fAllBins = new Float_t*[fRowsMax];
1066   fAllSigBins = new Int_t*[fRowsMax];
1067   fAllNSigBins = new Int_t[fRowsMax];
1068
1069   for (Int_t iRow = 0; iRow < fRowsMax; iRow++) {
1070     //
1071     Int_t maxBin = (fTimeBinsMax+4)*(fPadsMax+4);
1072     fAllBins[iRow] = new Float_t[maxBin];
1073     memset(fAllBins[iRow],0,sizeof(Float_t)*maxBin); // set all values to 0
1074     fAllSigBins[iRow] = new Int_t[maxBin];
1075     fAllNSigBins[iRow] = 0;
1076   }
1077 }
1078
1079
1080 //_____________________________________________________________________
1081 void AliTPCdataQA::CleanArrays(){
1082   //
1083   //
1084   //
1085
1086   for (Int_t iRow = 0; iRow < fRowsMax; iRow++) {
1087
1088     // To speed up the performance by a factor 2 on cosmic data (and
1089     // presumably pp data as well) where the ocupancy is low, the
1090     // memset is only called if there is more than 1000 signals for a
1091     // row (of the order 1% occupancy)
1092     if(fAllNSigBins[iRow]<1000) {
1093
1094       Float_t* allBins = fAllBins[iRow];
1095       Int_t* sigBins   = fAllSigBins[iRow];
1096       const Int_t nSignals = fAllNSigBins[iRow];
1097       for(Int_t i = 0; i < nSignals; i++)
1098         allBins[sigBins[i]]=0;
1099     } else {
1100
1101       Int_t maxBin = (fTimeBinsMax+4)*(fPadsMax+4);
1102       memset(fAllBins[iRow],0,sizeof(Float_t)*maxBin);
1103     }
1104
1105     fAllNSigBins[iRow]=0;
1106   }
1107 }
1108
1109 //_____________________________________________________________________
1110 void AliTPCdataQA::GetPadAndTimeBin(Int_t bin, Int_t& iPad, Int_t& iTimeBin){
1111   //
1112   // Return pad and timebin for a given bin
1113   //
1114
1115   //  Int_t bin = iPad*(fTimeBinsMax+4)+iTimeBin;
1116   iTimeBin  = bin%(fTimeBinsMax+4);
1117   iPad      = (bin-iTimeBin)/(fTimeBinsMax+4);
1118
1119   iPad     -= 2;
1120   iTimeBin -= 2;
1121   iTimeBin += fFirstTimeBin;
1122
1123   R__ASSERT(iPad>=0 && iPad<=fPadsMax);
1124   R__ASSERT(iTimeBin>=fFirstTimeBin && iTimeBin<=fLastTimeBin);
1125 }
1126
1127 //_____________________________________________________________________
1128 void AliTPCdataQA::SetExpandDigit(const Int_t iRow, Int_t iPad,
1129                                   Int_t iTimeBin, const Float_t signal)
1130 {
1131   //
1132   //
1133   //
1134   R__ASSERT(iRow>=0 && iRow<fRowsMax);
1135   R__ASSERT(iPad>=0 && iPad<=fPadsMax);
1136   R__ASSERT(iTimeBin>=fFirstTimeBin && iTimeBin<=fLastTimeBin);
1137
1138   iTimeBin -= fFirstTimeBin;
1139   iPad     += 2;
1140   iTimeBin += 2;
1141
1142   Int_t bin = iPad*(fTimeBinsMax+4)+iTimeBin;
1143   fAllBins[iRow][bin] = signal;
1144   fAllSigBins[iRow][fAllNSigBins[iRow]] = bin;
1145   fAllNSigBins[iRow]++;
1146 }
1147
1148 Float_t AliTPCdataQA::GetQ(const Float_t* adcArray, const Int_t time,
1149                            const Int_t pad, const Int_t maxTimeBins,
1150                            Int_t& timeMin, Int_t& timeMax,
1151                            Int_t& padMin,  Int_t& padMax) const
1152 {
1153   //
1154   // This methods return the charge in the bin time+pad*maxTimeBins
1155   // If the charge is above 0 it also updates the padMin, padMax, timeMin
1156   // and timeMax if necessary
1157   //
1158   Float_t charge = adcArray[time + pad*maxTimeBins];
1159   if(charge > 0) {
1160     timeMin = TMath::Min(time, timeMin); timeMax = TMath::Max(time, timeMax);
1161     padMin = TMath::Min(pad, padMin); padMax = TMath::Max(pad, padMax);
1162   }
1163   return charge;
1164 }
1165
1166 //______________________________________________________________________________
1167 void AliTPCdataQA::Streamer(TBuffer &xRuub)
1168 {
1169   // Automatic schema evolution was first used from revision 4
1170   // Code based on:
1171   // http://root.cern.ch/root/roottalk/roottalk02/3207.html
1172
1173    UInt_t xRuus, xRuuc;
1174    if (xRuub.IsReading()) {
1175       Version_t xRuuv = xRuub.ReadVersion(&xRuus, &xRuuc);
1176       //we use the automatic algorithm for class version > 3
1177       if (xRuuv > 3) {
1178         AliTPCdataQA::Class()->ReadBuffer(xRuub, this, xRuuv, xRuus,
1179                                           xRuuc);
1180         return;
1181       }
1182       TH1F::Streamer(xRuub);
1183       xRuub >> fFirstTimeBin;
1184       xRuub >> fLastTimeBin;
1185       xRuub >> fAdcMin;
1186       xRuub >> fAdcMax;
1187       xRuub >> fNLocalMaxima;
1188       xRuub >> fMaxCharge;
1189       xRuub >> fMeanCharge;
1190       xRuub >> fNoThreshold;
1191       xRuub >> fNTimeBins;
1192       xRuub >> fNPads;
1193       xRuub >> fTimePosition;
1194       xRuub >> fEventCounter;
1195       xRuub >> fIsAnalysed;
1196       xRuub.CheckByteCount(xRuus, xRuuc, AliTPCdataQA::IsA());
1197    } else {
1198      AliTPCdataQA::Class()->WriteBuffer(xRuub,this);
1199    }
1200 }