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