STEER/AliQAManager.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: AliQAManager.cxx 30894 2009-02-05 13:46:48Z schutz $ */
  17 ///////////////////////////////////////////////////////////////////////////////
  18 //                                                                           //
  19 // class for running the QA makers                                           //
  20 //                                                                           //
  21 //   AliQAManager qas;                                                       //
  22 //   qas.Run(AliQAv1::kRAWS, rawROOTFileName);                               //
  23 //   qas.Run(AliQAv1::kHITS);                                                //
  24 //   qas.Run(AliQAv1::kSDIGITS);                                             //
  25 //   qas.Run(AliQAv1::kDIGITS);                                              //
  26 //   qas.Run(AliQAv1::kRECPOINTS);                                           //
  27 //   qas.Run(AliQAv1::kESDS);                                                //
  28 //                                                                           //
  29 ///////////////////////////////////////////////////////////////////////////////
  30
  31 #include <TCanvas.h>
  32 #include <TKey.h>
  33 #include <TFile.h>
  34 #include <TFileMerger.h>
  35 #include <TGrid.h>
  36 #include <TGridCollection.h>
  37 #include <TGridResult.h>
  38 #include <TPluginManager.h>
  39 #include <TROOT.h>
  40 #include <TString.h>
  41 #include <TSystem.h>
  42 #include <TStopwatch.h>
  43
  44 #include "AliCDBManager.h"
  45 #include "AliCDBEntry.h"
  46 #include "AliCDBId.h"
  47 #include "AliCDBMetaData.h"
  48 #include "AliCodeTimer.h"
  49 #include "AliCorrQADataMakerRec.h"
  50 #include "AliDetectorRecoParam.h"
  51 #include "AliESDEvent.h"
  52 #include "AliGeomManager.h"
  53 #include "AliGlobalQADataMaker.h"
  54 #include "AliHeader.h"
  55 #include "AliLog.h"
  56 #include "AliModule.h"
  57 #include "AliQAv1.h"
  58 #include "AliQAChecker.h"
  59 #include "AliQACheckerBase.h"
  60 #include "AliQADataMakerRec.h"
  61 #include "AliQADataMakerSim.h"
  62 #include "AliQAManager.h"
  63 #include "AliRawReaderDate.h"
  64 #include "AliRawReaderFile.h"
  65 #include "AliRawReaderRoot.h"
  66 #include "AliRun.h"
  67 #include "AliRunLoader.h"
  68 #include "AliRunTag.h"
  69
  70 ClassImp(AliQAManager)
  71 AliQAManager* AliQAManager::fgQAInstance = 0x0;
  72
  73 //_____________________________________________________________________________
  74 AliQAManager::AliQAManager() :
  75   AliCDBManager(),
  76   fCurrentEvent(0),
  77   fCycleSame(kFALSE),
  78   fDetectors("ALL"),
  79   fDetectorsW("ALL"),
  80   fESD(NULL),
  81   fESDTree(NULL),
  82   fGAliceFileName(""),
  83   fFirstEvent(0),
  84   fMaxEvents(0),
  85   fMode(""),
  86   fNumberOfEvents(999999),
  87   fRecoParam(),
  88   fRunNumber(0),
  89   fRawReader(NULL),
  90   fRawReaderDelete(kTRUE),
  91   fRunLoader(NULL),
  92   fTasks(""),
  93   fEventSpecie(AliRecoParam::kDefault),
  94   fPrintImage(kTRUE),
  95   fSaveData(kTRUE)
  96 {
  97         // default ctor
  98         fMaxEvents = fNumberOfEvents ;
  99         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 100                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
 101                         fLoader[iDet]      = NULL ;
 102                         fQADataMaker[iDet] = NULL ;
 103                         fQACycles[iDet]    = 999999 ;
 104                 }
 105         }
 106   SetWriteExpert() ;
 107 }
 108
 109 //_____________________________________________________________________________
 110 AliQAManager::AliQAManager(AliQAv1::MODE_t mode, const Char_t* gAliceFilename) :
 111   AliCDBManager(),
 112   fCurrentEvent(0),
 113         fCycleSame(kFALSE),
 114         fDetectors("ALL"),
 115         fDetectorsW("ALL"),
 116         fESD(NULL),
 117         fESDTree(NULL),
 118         fGAliceFileName(gAliceFilename),
 119         fFirstEvent(0),
 120         fMaxEvents(0),
 121   fMode(AliQAv1::GetModeName(mode)),
 122         fNumberOfEvents(999999),
 123   fRecoParam(),
 124         fRunNumber(0),
 125         fRawReader(NULL),
 126         fRawReaderDelete(kTRUE),
 127         fRunLoader(NULL),
 128   fTasks(""),
 129   fEventSpecie(AliRecoParam::kDefault),
 130   fPrintImage(kTRUE),
 131   fSaveData(kTRUE)
 132 {
 133         // default ctor
 134         fMaxEvents = fNumberOfEvents ;
 135         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 136                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
 137                         fLoader[iDet]      = NULL ;
 138                         fQADataMaker[iDet] = NULL ;
 139                         fQACycles[iDet]    = 999999 ;
 140     }
 141   }
 142   SetWriteExpert() ;
 143 }
 144
 145 //_____________________________________________________________________________
 146 AliQAManager::AliQAManager(const AliQAManager & qas) :
 147   AliCDBManager(),
 148         fCurrentEvent(qas.fCurrentEvent),
 149         fCycleSame(kFALSE),
 150         fDetectors(qas.fDetectors),
 151         fDetectorsW(qas.fDetectorsW),
 152         fESD(NULL),
 153         fESDTree(NULL),
 154         fGAliceFileName(qas.fGAliceFileName),
 155         fFirstEvent(qas.fFirstEvent),
 156         fMaxEvents(qas.fMaxEvents),
 157         fMode(qas.fMode),
 158         fNumberOfEvents(qas.fNumberOfEvents),
 159         fRecoParam(),
 160         fRunNumber(qas.fRunNumber),
 161         fRawReader(NULL),
 162         fRawReaderDelete(kTRUE),
 163         fRunLoader(NULL),
 164   fTasks(qas.fTasks),
 165   fEventSpecie(qas.fEventSpecie),
 166   fPrintImage(qas.fPrintImage),
 167   fSaveData(qas.fSaveData)
 168
 169 {
 170         // cpy ctor
 171         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 172                 fLoader[iDet]         = qas.fLoader[iDet] ;
 173                 fQADataMaker[iDet]    = qas.fQADataMaker[iDet] ;
 174                 fQACycles[iDet]       = qas.fQACycles[iDet] ;
 175     fQAWriteExpert[iDet] = qas.fQAWriteExpert[iDet] ;
 176   }
 177 }
 178
 179 //_____________________________________________________________________________
 180 AliQAManager & AliQAManager::operator = (const AliQAManager & qas)
 181 {
 182         // assignment operator
 183   this->~AliQAManager() ;
 184   new(this) AliQAManager(qas) ;
 185   return *this ;
 186 }
 187
 188 //_____________________________________________________________________________
 189 AliQAManager::~AliQAManager()
 190 {
 191         // dtor
 192         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 193                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
 194                   fLoader[iDet] = NULL;
 195                   if (fQADataMaker[iDet]) {
 196                           (fQADataMaker[iDet])->Finish() ;
 197                                 delete fQADataMaker[iDet] ;
 198                   }
 199                 }
 200         }
 201         if (fRawReaderDelete) {
 202                 fRunLoader = NULL ;
 203                 delete fRawReader ;
 204                 fRawReader = NULL ;
 205         }
 206 }
 207 //_____________________________________________________________________________
 208 Bool_t AliQAManager::DoIt(const AliQAv1::TASKINDEX_t taskIndex)
 209 {
 210         // Runs all the QA data Maker for every detector
 211
 212         Bool_t rv = kFALSE ;
 213     // Fill QA data in event loop
 214         for (UInt_t iEvent = fFirstEvent ; iEvent < (UInt_t)fMaxEvents ; iEvent++) {
 215                 fCurrentEvent++ ;
 216                 // Get the event
 217                 if ( iEvent%10 == 0  )
 218                         AliDebug(AliQAv1::GetQADebugLevel(), Form("processing event %d", iEvent));
 219                 if ( taskIndex == AliQAv1::kRAWS ) {
 220                         if ( !fRawReader->NextEvent() )
 221                                 break ;
 222                 } else if ( taskIndex == AliQAv1::kESDS ) {
 223                         if ( fESDTree->GetEntry(iEvent) == 0 )
 224                                 break ;
 225                 } else {
 226                         if ( fRunLoader->GetEvent(iEvent) != 0 )
 227                                 break ;
 228                 }
 229                 // loop  over active loaders
 230                 for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 231                         if (IsSelected(AliQAv1::GetDetName(iDet))) {
 232                                 AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 233                                 if (!qadm) continue; // This detector doesn't have any QA (for example, HLT)
 234                                 if ( qadm->IsCycleDone() ) {
 235           qadm->EndOfCycle(taskIndex) ;
 236                                 }
 237                                 TTree * data = NULL ;
 238                                 AliLoader* loader = GetLoader(qadm->GetUniqueID());
 239                                 switch (taskIndex) {
 240                                         case AliQAv1::kNULLTASKINDEX :
 241                                                 break ;
 242                                         case AliQAv1::kRAWS :
 243                                                 qadm->Exec(taskIndex, fRawReader) ;
 244                                                 break ;
 245                                         case AliQAv1::kHITS :
 246             if( loader ) {
 247               loader->LoadHits() ;
 248               data = loader->TreeH() ;
 249               if ( ! data ) {
 250                 AliWarning(Form(" Hit Tree not found for  %s", AliQAv1::GetDetName(iDet))) ;
 251                 break ;
 252               }
 253               qadm->Exec(taskIndex, data) ;
 254             }
 255                                                 break ;
 256                                                 case AliQAv1::kSDIGITS :
 257           {
 258
 259             TString fileName(Form("%s.SDigits.root", AliQAv1::GetDetName(iDet))) ;
 260             if (gSystem->FindFile("./", fileName)) {
 261               if( loader ) {
 262                 loader->LoadSDigits() ;
 263                 data = loader->TreeS() ;
 264                 if ( ! data ) {
 265                   AliWarning(Form(" SDigit Tree not found for  %s", AliQAv1::GetDetName(iDet))) ;
 266                   break ;
 267                 }
 268                 qadm->Exec(taskIndex, data) ;
 269               }
 270             }
 271           }
 272                                                 break;
 273                                                 case AliQAv1::kDIGITS :
 274               if( loader ) {
 275                 loader->LoadDigits() ;
 276                 data = loader->TreeD() ;
 277                 if ( ! data ) {
 278                   AliWarning(Form(" Digit Tree not found for  %s", AliQAv1::GetDetName(iDet))) ;
 279                   break ;
 280                 }
 281                 qadm->Exec(taskIndex, data) ;
 282               }
 283             break;
 284             case AliQAv1::kDIGITSR :
 285               if( loader ) {
 286                 loader->LoadDigits() ;
 287                 data = loader->TreeD() ;
 288                 if ( ! data ) {
 289                   AliWarning(Form(" Digit Tree not found for  %s", AliQAv1::GetDetName(iDet))) ;
 290                   break ;
 291                 }
 292                 qadm->Exec(taskIndex, data) ;
 293               }
 294                                                 break;
 295                                                 case AliQAv1::kRECPOINTS :
 296             if( loader ) {
 297               loader->LoadRecPoints() ;
 298               data = loader->TreeR() ;
 299               if (!data) {
 300                 AliWarning(Form("RecPoints not found for %s", AliQAv1::GetDetName(iDet))) ;
 301                 break ;
 302               }
 303               qadm->Exec(taskIndex, data) ;
 304             }
 305             break;
 306                                                 case AliQAv1::kTRACKSEGMENTS :
 307                                                 break;
 308                                                 case AliQAv1::kRECPARTICLES :
 309                                                 break;
 310                                                 case AliQAv1::kESDS :
 311                                                 qadm->Exec(taskIndex, fESD) ;
 312                                                 break;
 313                                                 case AliQAv1::kNTASKINDEX :
 314                                                 break;
 315                                 } //task switch
 316                         }
 317                 } // detector loop
 318     Increment(taskIndex) ;
 319         } // event loop
 320         // Save QA data for all detectors
 321
 322   EndOfCycle() ;
 323
 324         if ( taskIndex == AliQAv1::kRAWS )
 325                 fRawReader->RewindEvents() ;
 326
 327         return rv ;
 328 }
 329
 330 //_____________________________________________________________________________
 331 Bool_t AliQAManager::Finish(const AliQAv1::TASKINDEX_t taskIndex)
 332 {
 333         // write output to file for all detectors
 334
 335   AliQAChecker::Instance()->SetRunNumber(fRunNumber) ;
 336
 337         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 338                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
 339                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 340                         if (qadm)
 341         qadm->EndOfCycle(taskIndex) ;
 342                 }
 343         }
 344         return kTRUE ;
 345 }
 346
 347 //_____________________________________________________________________________
 348 TObjArray * AliQAManager::GetFromOCDB(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, const Char_t * year) const
 349 {
 350         // Retrieve the list of QA data for a given detector and a given task
 351         TObjArray * rv = NULL ;
 352         if ( !strlen(AliQAv1::GetQARefStorage()) ) {
 353                 AliError("No storage defined, use AliQAv1::SetQARefStorage") ;
 354                 return NULL ;
 355         }
 356         if ( ! IsDefaultStorageSet() ) {
 357                 TString tmp(AliQAv1::GetQARefDefaultStorage()) ;
 358                 tmp.Append(year) ;
 359                 tmp.Append("/") ;
 360                 Instance()->SetDefaultStorage(tmp.Data()) ;
 361                 Instance()->SetSpecificStorage(Form("%s/*", AliQAv1::GetQAName()), AliQAv1::GetQARefStorage()) ;
 362         }
 363         TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetQAName(), AliQAv1::GetDetName((Int_t)det), AliQAv1::GetRefOCDBDirName())) ;
 364      AliDebug(AliQAv1::GetQADebugLevel(), Form("Retrieving reference data from %s/%s for %s", AliQAv1::GetQARefStorage(), detOCDBDir.Data(), AliQAv1::GetTaskName(task).Data())) ;
 365         AliCDBEntry* entry = QAManager()->Get(detOCDBDir.Data(), 0) ; //FIXME 0 --> Run Number
 366         TList * listDetQAD = static_cast<TList *>(entry->GetObject()) ;
 367         if ( listDetQAD )
 368                 rv = static_cast<TObjArray *>(listDetQAD->FindObject(AliQAv1::GetTaskName(task))) ;
 369         return rv ;
 370 }
 371
 372 //_____________________________________________________________________________
 373 TCanvas ** AliQAManager::GetImage(Char_t * detName)
 374 {
 375   // retrieves QA Image for the given detector
 376   TCanvas ** rv = NULL ;
 377   Int_t detIndex = AliQAv1::GetDetIndex(detName) ;
 378   if ( detIndex != AliQAv1::kNULLDET) {
 379     AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(detIndex) ;
 380     rv = qac->GetImage() ;
 381   }
 382   return rv ;
 383 }
 384
 385 //_____________________________________________________________________________
 386 AliLoader * AliQAManager::GetLoader(Int_t iDet)
 387 {
 388         // get the loader for a detector
 389
 390         if ( !fRunLoader || iDet == AliQAv1::kCORR || iDet == AliQAv1::kGLOBAL )
 391                 return NULL ;
 392
 393         TString detName = AliQAv1::GetDetName(iDet) ;
 394     fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
 395         if (fLoader[iDet])
 396                 return fLoader[iDet] ;
 397
 398         // load the QA data maker object
 399         TPluginManager* pluginManager = gROOT->GetPluginManager() ;
 400         TString loaderName = "Ali" + detName + "Loader" ;
 401
 402         AliLoader * loader = NULL ;
 403         // first check if a plugin is defined for the quality assurance data maker
 404         TPluginHandler* pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
 405         // if not, add a plugin for it
 406         if (!pluginHandler) {
 407                 AliDebug(AliQAv1::GetQADebugLevel(), Form("defining plugin for %s", loaderName.Data())) ;
 408                 TString libs = gSystem->GetLibraries() ;
 409                 if (libs.Contains("lib" + detName + "base.so") || (gSystem->Load("lib" + detName + "base.so") >= 0)) {
 410                         pluginManager->AddHandler("AliQADataMaker", detName, loaderName, detName + "loader", loaderName + "()") ;
 411                 } else {
 412                         pluginManager->AddHandler("AliLoader", detName, loaderName, detName, loaderName + "()") ;
 413                 }
 414                 pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
 415         }
 416         if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
 417                 loader = (AliLoader *) pluginHandler->ExecPlugin(0) ;
 418         }
 419         if (loader)
 420                 fLoader[iDet] = loader ;
 421         return loader ;
 422 }
 423
 424 //_____________________________________________________________________________
 425 AliQAv1 * AliQAManager::GetQA(UInt_t run, UInt_t evt)
 426 {
 427 // retrieves the QA object stored in a file named "Run{run}.Event{evt}_1.ESD.tag.root"
 428   Char_t * fileName = Form("Run%d.Event%d_1.ESD.tag.root", run, evt) ;
 429   TFile * tagFile = TFile::Open(fileName) ;
 430   if ( !tagFile ) {
 431     AliError(Form("File %s not found", fileName)) ;
 432     return NULL ;
 433   }
 434   TTree * tagTree = static_cast<TTree *>(tagFile->Get("T")) ;
 435   if ( !tagTree ) {
 436     AliError(Form("Tree T not found in %s", fileName)) ;
 437     tagFile->Close() ;
 438     return NULL ;
 439   }
 440   AliRunTag * tag = new AliRunTag ;
 441   tagTree->SetBranchAddress("AliTAG", &tag) ;
 442   tagTree->GetEntry(evt) ;
 443   AliQAv1 * qa = AliQAv1::Instance(tag->GetQALength(), tag->GetQAArray(), tag->GetESLength(), tag->GetEventSpecies()) ;
 444   tagFile->Close() ;
 445   return qa ;
 446 }
 447
 448 //_____________________________________________________________________________
 449 AliQADataMaker * AliQAManager::GetQADataMaker(const Int_t iDet)
 450 {
 451         // get the quality assurance data maker for a detector
 452
 453   AliQADataMaker * qadm =  fQADataMaker[iDet] ;
 454
 455         if (qadm) {
 456
 457     qadm->SetEventSpecie(fEventSpecie) ;
 458     if ( qadm->GetRecoParam() )
 459       if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
 460         qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
 461
 462   } else if (iDet == AliQAv1::kGLOBAL && strcmp(GetMode(), AliQAv1::GetModeName(AliQAv1::kRECMODE)) == 0) { //Global QA
 463
 464                 qadm = new AliGlobalQADataMaker();
 465                 qadm->SetName(AliQAv1::GetDetName(iDet));
 466                 qadm->SetUniqueID(iDet);
 467                 fQADataMaker[iDet] = qadm;
 468     qadm->SetEventSpecie(fEventSpecie) ;
 469     if ( qadm->GetRecoParam() )
 470       if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
 471         qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
 472
 473         }       else if (iDet == AliQAv1::kCORR && strcmp(GetMode(), AliQAv1::GetModeName(AliQAv1::kRECMODE)) == 0 ) { //the data maker for correlations among detectors
 474     qadm = new AliCorrQADataMakerRec(fQADataMaker) ;
 475                 qadm->SetName(AliQAv1::GetDetName(iDet));
 476                 qadm->SetUniqueID(iDet);
 477                 fQADataMaker[iDet] = qadm;
 478     qadm->SetEventSpecie(fEventSpecie) ;
 479     if ( qadm->GetRecoParam() )
 480       if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
 481         qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
 482
 483   } else if ( iDet < AliQAv1::kGLOBAL ) {
 484     TString  smode(GetMode()) ;
 485     if (smode.Contains(AliQAv1::GetModeName(AliQAv1::kQAMODE)))
 486       smode = AliQAv1::GetModeName(AliQAv1::kRECMODE) ;
 487     // load the QA data maker object
 488     TPluginManager* pluginManager = gROOT->GetPluginManager() ;
 489     TString detName = AliQAv1::GetDetName(iDet) ;
 490     TString qadmName = "Ali" + detName + "QADataMaker" + smode ;
 491
 492     // first check if a plugin is defined for the quality assurance data maker
 493     TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
 494     // if not, add a plugin for it
 495     if (!pluginHandler) {
 496       AliDebug(AliQAv1::GetQADebugLevel(), Form("defining plugin for %s", qadmName.Data())) ;
 497       TString libs = gSystem->GetLibraries() ;
 498       TString temp(smode) ;
 499       temp.ToLower() ;
 500       if (libs.Contains("lib" + detName + smode + ".so") || (gSystem->Load("lib" + detName + temp.Data() + ".so") >= 0)) {
 501         pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName + "qadm", qadmName + "()") ;
 502       } else {
 503         pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName, qadmName + "()") ;
 504       }
 505       pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
 506     }
 507     if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
 508       qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0) ;
 509     }
 510     if (qadm) {
 511       qadm->SetName(AliQAv1::GetDetName(iDet));
 512       qadm->SetUniqueID(iDet);
 513       fQADataMaker[iDet] = qadm ;
 514       qadm->SetEventSpecie(fEventSpecie) ;
 515       if ( qadm->GetRecoParam() )
 516         if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
 517           qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
 518     }
 519   }
 520   return qadm ;
 521 }
 522
 523 //_____________________________________________________________________________
 524 void  AliQAManager::EndOfCycle(TObjArray * detArray)
 525 {
 526         // End of cycle QADataMakers
 527
 528   AliQAChecker::Instance()->SetRunNumber(fRunNumber) ;
 529   TCanvas fakeCanvas ;
 530
 531     fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ;
 532         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 533                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
 534                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 535                         if (!qadm)
 536                                 continue ;
 537                         // skip non active detectors
 538                         if (detArray) {
 539                                 AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQAv1::GetDetName(iDet))) ;
 540                                 if (!det || !det->IsActive())
 541                                         continue ;
 542                         }
 543                         AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(iDet) ;
 544       if (qac)
 545         qac->SetPrintImage(fPrintImage) ;
 546       for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
 547         if ( fTasks.Contains(Form("%d", taskIndex)) )
 548           qadm->EndOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex))) ;
 549       }
 550                         qadm->Finish();
 551                 }
 552         }
 553   if (fPrintImage)
 554     fakeCanvas.Print(Form("%s%s%d.%s]", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps");
 555 }
 556
 557 //_____________________________________________________________________________
 558 void  AliQAManager::EndOfCycle(TString detectors)
 559 {
 560         // End of cycle QADataMakers
 561
 562   AliQAChecker::Instance()->SetRunNumber(fRunNumber) ;
 563   TCanvas fakeCanvas ;
 564   if (fPrintImage)
 565     fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ;
 566   for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 567                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
 568                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 569                         if (!qadm)
 570                                 continue ;
 571                         // skip non active detectors
 572       if (!detectors.Contains(AliQAv1::GetDetName(iDet)))
 573         continue ;
 574                         AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(iDet) ;
 575       if (qac)
 576         qac->SetPrintImage(fPrintImage) ;
 577       for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
 578         if ( fTasks.Contains(Form("%d", taskIndex)) )
 579           qadm->EndOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex))) ;
 580       }
 581                         qadm->Finish();
 582                 }
 583         }
 584   if (fPrintImage)
 585     fakeCanvas.Print(Form("%s%s%d.%s]", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps");
 586 }
 587
 588 //_____________________________________________________________________________
 589 AliRecoParam::EventSpecie_t AliQAManager::GetEventSpecieFromESD()
 590 {
 591   AliRecoParam::EventSpecie_t runtype = AliRecoParam::kDefault ;
 592   if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
 593     TFile * esdFile = TFile::Open("AliESDs.root") ;
 594     TTree * esdTree = static_cast<TTree *> (esdFile->Get("esdTree")) ;
 595     if ( !esdTree ) {
 596       AliError("esdTree not found") ;
 597     } else {
 598       AliESDEvent * esd    = new AliESDEvent() ;
 599       esd->ReadFromTree(esdTree) ;
 600       esdTree->GetEntry(0) ;
 601       runtype = AliRecoParam::Convert(esd->GetEventType()) ;
 602     }
 603   } else {
 604     AliError("AliESDs.root not found") ;
 605   }
 606   return runtype ;
 607 }
 608
 609 //_____________________________________________________________________________
 610 void AliQAManager::Increment(const AliQAv1::TASKINDEX_t taskIndex)
 611 {
 612   // Increments the cycle counter for all QA Data Makers
 613   static AliQAv1::TASKINDEX_t currentTask = AliQAv1::kNTASKINDEX ;
 614   if ( (currentTask == taskIndex) && taskIndex != AliQAv1::kNULLTASKINDEX )
 615     return ;
 616   else
 617     currentTask = taskIndex ;
 618         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 619                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
 620                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 621                         if (qadm)
 622         qadm->Increment() ;
 623     }
 624   }
 625 }
 626
 627 //_____________________________________________________________________________
 628 Bool_t AliQAManager::InitQA(const AliQAv1::TASKINDEX_t taskIndex, const  Char_t * input )
 629 {
 630         // Initialize the event source and QA data makers
 631
 632         fTasks += Form("%d", taskIndex) ;
 633
 634         if (taskIndex == AliQAv1::kRAWS) {
 635                 if (!fRawReader) {
 636                         fRawReader = AliRawReader::Create(input);
 637                 }
 638                 if ( ! fRawReader )
 639                         return kFALSE ;
 640                 fRawReaderDelete = kTRUE ;
 641                 fRawReader->NextEvent() ;
 642                 fRunNumber = fRawReader->GetRunNumber() ;
 643                 SetRun(fRunNumber) ;
 644                 fRawReader->RewindEvents();
 645                 fNumberOfEvents = 999999 ;
 646                 if ( fMaxEvents < 0 )
 647                         fMaxEvents = fNumberOfEvents ;
 648                 } else if (taskIndex == AliQAv1::kESDS) {
 649                         fTasks = AliQAv1::GetTaskName(AliQAv1::kESDS) ;
 650       if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
 651         TFile * esdFile = TFile::Open("AliESDs.root") ;
 652         fESDTree = static_cast<TTree *> (esdFile->Get("esdTree")) ;
 653         if ( !fESDTree ) {
 654           AliError("esdTree not found") ;
 655           return kFALSE ;
 656         } else {
 657           fESD     = new AliESDEvent() ;
 658           fESD->ReadFromTree(fESDTree) ;
 659           fESDTree->GetEntry(0) ;
 660           fRunNumber = fESD->GetRunNumber() ;
 661           fNumberOfEvents = fESDTree->GetEntries() ;
 662           if ( fMaxEvents < 0 )
 663             fMaxEvents = fNumberOfEvents ;
 664         }
 665       } else {
 666         AliError("AliESDs.root not found") ;
 667         return kFALSE ;
 668       }
 669     } else {
 670       if ( !InitRunLoader() ) {
 671         AliWarning("No Run Loader not found") ;
 672       } else {
 673         fNumberOfEvents = fRunLoader->GetNumberOfEvents() ;
 674         if ( fMaxEvents < 0 )
 675           fMaxEvents = fNumberOfEvents ;
 676       }
 677     }
 678
 679   // Get Detectors
 680   TObjArray* detArray = NULL ;
 681         if (fRunLoader) // check if RunLoader exists
 682                 if ( fRunLoader->GetAliRun() ) { // check if AliRun exists in gAlice.root
 683                         detArray = fRunLoader->GetAliRun()->Detectors() ;
 684                         fRunNumber = fRunLoader->GetHeader()->GetRun() ;
 685                 }
 686
 687         // Initialize all QA data makers for all detectors
 688         fRunNumber = AliCDBManager::Instance()->GetRun() ;
 689         if ( !  AliGeomManager::GetGeometry() )
 690                 AliGeomManager::LoadGeometry() ;
 691
 692         InitQADataMaker(fRunNumber, detArray) ; //, fCycleSame, kTRUE, detArray) ;
 693   if (fPrintImage) {
 694     TCanvas fakeCanvas ;
 695     TStopwatch timer ;
 696     timer.Start() ;
 697     while (timer.CpuTime()<5) {
 698       timer.Continue();
 699       gSystem->ProcessEvents();
 700     }
 701     fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ;
 702   }
 703         return kTRUE ;
 704 }
 705
 706 //_____________________________________________________________________________
 707 void  AliQAManager::InitQADataMaker(UInt_t run, TObjArray * detArray)
 708 {
 709         // Initializes The QADataMaker for all active detectors and for all active tasks
 710   fRunNumber = run ;
 711         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 712                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
 713                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 714                         if (!qadm) {
 715                                 AliError(Form("AliQADataMaker not found for %s", AliQAv1::GetDetName(iDet))) ;
 716                                 fDetectorsW.ReplaceAll(AliQAv1::GetDetName(iDet), "") ;
 717                         } else {
 718         if (fQAWriteExpert[iDet])
 719           qadm->SetWriteExpert() ;
 720                                 AliDebug(AliQAv1::GetQADebugLevel(), Form("Data Maker found for %s %d", qadm->GetName(), qadm->WriteExpert())) ;
 721                                 // skip non active detectors
 722                                 if (detArray) {
 723                                         AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQAv1::GetDetName(iDet))) ;
 724                                         if (!det || !det->IsActive())
 725                                                 continue ;
 726                                 }
 727               // Set default reco params
 728         Bool_t sameCycle = kFALSE ;
 729                                 for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
 730                                         if ( fTasks.Contains(Form("%d", taskIndex)) ) {
 731                                                 qadm->Init(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), GetQACycles(qadm->GetUniqueID())) ;
 732             qadm->StartOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), run,  sameCycle) ;
 733             sameCycle = kTRUE ;
 734                                         }
 735                                 }
 736                         }
 737                 }
 738         }
 739 }
 740
 741
 742 //_____________________________________________________________________________
 743 Bool_t AliQAManager::InitRunLoader()
 744 {
 745         // get or create the run loader
 746         if (fRunLoader) {
 747                 fCycleSame = kTRUE ;
 748         } else {
 749                 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
 750                         // load all base libraries to get the loader classes
 751                         TString libs = gSystem->GetLibraries() ;
 752                         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 753                                 if (!IsSelected(AliQAv1::GetDetName(iDet)))
 754                                         continue ;
 755                                 TString detName = AliQAv1::GetDetName(iDet) ;
 756                                 if (detName == "HLT")
 757                                         continue;
 758                                 if (libs.Contains("lib" + detName + "base.so"))
 759                                         continue;
 760                                 gSystem->Load("lib" + detName + "base.so");
 761                         }
 762                         fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
 763                         if (!fRunLoader) {
 764                                 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
 765                                 return kFALSE;
 766                         }
 767                         fRunLoader->CdGAFile();
 768                         if (fRunLoader->LoadgAlice() == 0) {
 769                                 gAlice = fRunLoader->GetAliRun();
 770                         }
 771
 772                         if (!gAlice) {
 773                                 AliError(Form("no gAlice object found in file %s", fGAliceFileName.Data()));
 774                                 return kFALSE;
 775                         }
 776
 777                 } else {               // galice.root does not exist
 778                         AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
 779                         return kFALSE;
 780                 }
 781         }
 782
 783         if (!fRunNumber) {
 784                 fRunLoader->LoadHeader();
 785                 fRunNumber = fRunLoader->GetHeader()->GetRun() ;
 786         }
 787         return kTRUE;
 788 }
 789
 790 //_____________________________________________________________________________
 791 Bool_t AliQAManager::IsSelected(const Char_t * det)
 792 {
 793   // check whether detName is contained in detectors
 794         // if yes, it is removed from detectors
 795
 796         Bool_t rv = kFALSE;
 797         const TString detName(det) ;
 798   // always activates Correlation
 799   if ( detName.Contains(AliQAv1::GetDetName(AliQAv1::kCORR)) || detName.Contains(AliQAv1::GetDetName(AliQAv1::kGLOBAL))) {
 800     rv = kTRUE ;
 801   } else {
 802     // check if all detectors are selected
 803     if (fDetectors.Contains("ALL")) {
 804       fDetectors = "ALL";
 805       rv = kTRUE;
 806     } else if ((fDetectors.CompareTo(detName) == 0) ||
 807                fDetectors.BeginsWith(detName+" ") ||
 808                fDetectors.EndsWith(" "+detName) ||
 809                fDetectors.Contains(" "+detName+" ")) {
 810       rv = kTRUE;
 811     }
 812   }
 813         return rv ;
 814 }
 815
 816 //_____________________________________________________________________________
 817 Bool_t AliQAManager::Merge(Int_t runNumber, const char *fileName) const
 818 {
 819         // Merge data from all detectors from a given run in one single file
 820         // Merge the QA results from all the data chunks in one run
 821   // The 'fileName' is name of the output file with merged QA data
 822  if ( runNumber == -1)
 823    runNumber = fRunNumber ;
 824  Bool_t rv = MergeData(runNumber,fileName) ;
 825  //rv *= MergeResults(runNumber) ; // not needed for the time being
 826  return rv ;
 827 }
 828
 829 //______________________________________________________________________
 830 Bool_t AliQAManager::MergeXML(const Char_t * collectionFile, const Char_t * subFile, const Char_t * outFile)
 831 {
 832   // merges files listed in a xml collection
 833   // usage Merge(collection, outputFile))
 834   //              collection: is a xml collection
 835
 836   Bool_t rv = kFALSE ;
 837
 838   if ( strstr(collectionFile, ".xml") == 0 ) {
 839     AliError("Input collection file must be an \".xml\" file\n") ;
 840     return kFALSE ;
 841   }
 842
 843  if ( !gGrid )
 844    TGrid::Connect("alien://");
 845  if ( !gGrid )
 846    return kFALSE ;
 847
 848   // Open the file collection
 849   AliInfoClass(Form("*** Create Collection       ***\n***  Wk-Dir = |%s|             \n***  Coll   = |%s|             \n",gSystem->WorkingDirectory(), collectionFile));
 850
 851   TGridCollection * collection = (TGridCollection*)gROOT->ProcessLine(Form("TAlienCollection::Open(\"%s\")",collectionFile));
 852   TGridResult* result = collection->GetGridResult("", 0, 0);
 853
 854   Int_t index = 0  ;
 855   const Char_t * turl ;
 856   TFileMerger merger(kFALSE) ;
 857   if (!outFile) {
 858     TString tempo(collectionFile) ;
 859     if ( subFile)
 860       tempo.ReplaceAll(".xml", subFile) ;
 861     else
 862       tempo.ReplaceAll(".xml", "_Merged.root") ;
 863     outFile = tempo.Data() ;
 864   }
 865   merger.OutputFile(outFile) ;
 866
 867   while ( (turl = result->GetKey(index, "turl")) ) {
 868     Char_t * file ;
 869     if ( subFile )
 870       file = Form("%s#%s", turl, subFile) ;
 871     else
 872       file = Form("%s", turl) ;
 873
 874     AliDebug(AliQAv1::GetQADebugLevel(), Form("%s\n", file)) ;
 875     merger.AddFile(file) ;
 876     index++ ;
 877   }
 878
 879   if (index)
 880     merger.Merge() ;
 881
 882   AliDebug(AliQAv1::GetQADebugLevel(), Form("Files merged into %s\n", outFile)) ;
 883
 884   rv = kFALSE;
 885   return rv ;
 886 }
 887
 888 //_____________________________________________________________________________
 889 void AliQAManager::MergeCustom() const
 890 {
 891         // Custom Merge of QA data from all detectors for all runs in one single file
 892   // search all the run numbers
 893   // search all the run numbers
 894   gROOT->ProcessLine(".! ls *QA*.root > QAtempo.txt") ;
 895   TString QAfile ;
 896   FILE * QAfiles = fopen("QAtempo.txt", "r") ;
 897   Int_t index = 0 ;
 898   TList srunList ;
 899   TIter nextRun(&srunList) ;
 900   TObjString * srun = NULL ;
 901   Int_t loRun = 999999999 ;
 902   Int_t hiRun = 0 ;
 903   while ( QAfile.Gets(QAfiles) ) {
 904     Bool_t runExist = kFALSE ;
 905     TString srunNew(QAfile(QAfile.Index("QA.")+3, QAfile.Index(".root")-(QAfile.Index("QA.")+3))) ;
 906     Int_t cuRun = srunNew.Atoi() ;
 907     if (cuRun < loRun)
 908       loRun = cuRun ;
 909     if (cuRun > hiRun)
 910       hiRun = cuRun ;
 911     while ( (srun = static_cast<TObjString *> (nextRun())) ) {
 912       if ( cuRun == (srun->String()).Atoi() ) {
 913         runExist = kTRUE ;
 914         break ;
 915       }
 916     }
 917     nextRun.Reset() ;
 918     if ( ! runExist )
 919       srunList.Add(new TObjString(srunNew.Data()));
 920   }
 921   nextRun.Reset() ;
 922   Int_t runNumber = 0 ;
 923   TFile mergedFile(Form("Merged.%s.Data.root", AliQAv1::GetQADataFileName()), "RECREATE") ;
 924   TH1I * hisRun = new TH1I("hLMR", "List of merged runs", hiRun-loRun+10, loRun, hiRun+10) ;
 925   // create the structure into the merged file
 926   for (Int_t iDet = 0; iDet < AliQAv1::kNDET ; iDet++) {
 927     TDirectory * detDir = mergedFile.mkdir(AliQAv1::GetDetName(iDet)) ;
 928     for (Int_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
 929       detDir->cd() ;
 930       TDirectory * taskDir = gDirectory->mkdir(AliQAv1::GetTaskName(taskIndex)) ;
 931       for (Int_t es = 0 ; es < AliRecoParam::kNSpecies ; es++) {
 932         taskDir->cd() ;
 933         TDirectory * esDir = gDirectory->mkdir(AliRecoParam::GetEventSpecieName(es)) ;
 934         esDir->cd() ;
 935         gDirectory->mkdir(AliQAv1::GetExpert()) ;
 936       }
 937     }
 938   }
 939   while ( (srun = static_cast<TObjString *> (nextRun())) ) {
 940     runNumber = (srun->String()).Atoi() ;
 941     hisRun->Fill(runNumber) ;
 942     AliDebug(AliQAv1::GetQADebugLevel(), Form("Merging run number %d", runNumber)) ;
 943     // search all QA files for runNumber in the current directory
 944     Char_t * fileList[AliQAv1::kNDET] ;
 945     index = 0 ;
 946     for (Int_t iDet = 0; iDet < AliQAv1::kNDET ; iDet++) {
 947       Char_t * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQAv1::GetDetName(iDet), AliQAv1::GetQADataFileName(), runNumber));
 948       if (file)
 949         fileList[index++] = file ;
 950     }
 951     if ( index == 0 ) {
 952       AliError("No QA data file found\n") ;
 953       return ;
 954     }
 955     for ( Int_t i = 0 ; i < index ; i++) {
 956       TFile * inFile = TFile::Open(fileList[i]) ;
 957       TList * listOfKeys =inFile->GetListOfKeys() ;
 958       TIter nextkey(listOfKeys) ;
 959       TObject * obj1 ;
 960       TString dirName("") ;
 961       while ( (obj1 = nextkey()) ) {
 962         TDirectory * directoryDet = inFile->GetDirectory(obj1->GetName()) ;
 963         if ( directoryDet ) {
 964           AliDebug(AliQAv1::GetQADebugLevel(), Form("%s dir = %s", inFile->GetName(), directoryDet->GetName())) ;
 965           dirName += Form("%s/", directoryDet->GetName() ) ;
 966           directoryDet->cd() ;
 967           TList * listOfTasks = directoryDet->GetListOfKeys() ;
 968           TIter nextTask(listOfTasks) ;
 969           TObject * obj2 ;
 970           while ( (obj2 = nextTask()) ) {
 971             TDirectory * directoryTask = directoryDet->GetDirectory(obj2->GetName()) ;
 972             if ( directoryTask ) {
 973               dirName += Form("%s", obj2->GetName()) ;
 974               AliDebug(AliQAv1::GetQADebugLevel(), Form("%s", dirName.Data())) ;
 975               directoryTask->cd() ;
 976               TList * listOfEventSpecie = directoryTask->GetListOfKeys() ;
 977               TIter nextEventSpecie(listOfEventSpecie) ;
 978               TObject * obj3 ;
 979               while ( (obj3 = nextEventSpecie()) ) {
 980                 TDirectory * directoryEventSpecie = directoryTask->GetDirectory(obj3->GetName()) ;
 981                 if ( directoryEventSpecie ) {
 982                   dirName += Form("/%s/", obj3->GetName()) ;
 983                   AliDebug(AliQAv1::GetQADebugLevel(), Form("%s\n", dirName.Data())) ;
 984                   directoryEventSpecie->cd() ;
 985                   // histograms are here
 986                   TDirectory * mergedDirectory = mergedFile.GetDirectory(dirName.Data()) ;
 987                   TList * listOfData = directoryEventSpecie->GetListOfKeys() ;
 988                   TIter nextData(listOfData) ;
 989                   TKey * key ;
 990                   while ( (key = static_cast<TKey *>(nextData())) ) {
 991                     TString className(key->GetClassName()) ;
 992                     if (  className.Contains("TH") || className.Contains("TProfile") ) {
 993                       TH1 * histIn = static_cast<TH1*> (key->ReadObj()) ;
 994                       TH1 * histOu = static_cast<TH1*> (mergedDirectory->FindObjectAny(histIn->GetName())) ;
 995                       AliDebug(AliQAv1::GetQADebugLevel(), Form("%s %p %p\n", key->GetName(), histIn, histOu)) ;
 996                       mergedDirectory->cd() ;
 997                       if ( ! histOu ) {
 998                         histIn->Write() ;
 999                       } else {
1000                         histOu->Add(histIn) ;
1001                         histOu->Write(histOu->GetName(), kOverwrite) ;
1002                       }
1003                     }
1004                     else if ( className.Contains("TDirectoryFile") ) {
1005                       TDirectory * dirExpert = directoryEventSpecie->GetDirectory(key->GetName()) ;
1006                       dirExpert->cd() ;
1007                       TDirectory * mergedDirectoryExpert = mergedDirectory->GetDirectory(dirExpert->GetName()) ;
1008                       TList * listOfExpertData = dirExpert->GetListOfKeys() ;
1009                       TIter nextExpertData(listOfExpertData) ;
1010                       TKey * keykey ;
1011                       while ( (keykey = static_cast<TKey *>(nextExpertData())) ) {
1012                         TString classNameExpert(keykey->GetClassName()) ;
1013                         if (classNameExpert.Contains("TH")) {
1014                           TH1 * histInExpert = static_cast<TH1*> (keykey->ReadObj()) ;
1015                           TH1 * histOuExpert = static_cast<TH1*> (mergedDirectory->FindObjectAny(histInExpert->GetName())) ;
1016                           mergedDirectoryExpert->cd() ;
1017                           if ( ! histOuExpert ) {
1018                             histInExpert->Write() ;
1019                           } else {
1020                             histOuExpert->Add(histInExpert) ;
1021                             histOuExpert->Write(histOuExpert->GetName(), kOverwrite) ;
1022                           }
1023                         }
1024                       }
1025                     } else {
1026                       AliError(Form("No merge done for this object %s in %s", key->GetName(), dirName.Data())) ;
1027                     }
1028                   }
1029                   dirName.ReplaceAll(Form("/%s/",obj3->GetName()), "") ;
1030                 }
1031               }
1032               dirName.ReplaceAll(obj2->GetName(), "") ;
1033             }
1034           }
1035         }
1036       }
1037       inFile->Close() ;
1038     }
1039   }
1040   mergedFile.cd() ;
1041   hisRun->Write() ;
1042   mergedFile.Close() ;
1043   srunList.Delete() ;
1044 }
1045
1046 //_____________________________________________________________________________
1047 Bool_t AliQAManager::MergeData(const Int_t runNumber, const char *fileName) const
1048 {
1049         // Merge QA data from all detectors for a given run in one single file
1050
1051   TFileMerger merger(kFALSE) ;
1052   TString outFileName = fileName;
1053   if (outFileName.IsNull()) outFileName.Form("Merged.%s.Data.root",AliQAv1::GetQADataFileName());
1054   merger.OutputFile(outFileName.Data()) ;
1055   for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
1056     Char_t * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQAv1::GetDetName(iDet), AliQAv1::GetQADataFileName(), runNumber));
1057     if (file)
1058       merger.AddFile(file);
1059     delete[] file;
1060   }
1061   merger.Merge() ;
1062         return kTRUE ;
1063 }
1064
1065 //_____________________________________________________________________________
1066 Bool_t AliQAManager::MergeResults(const Int_t runNumber) const
1067 {
1068         // Merge the QA result from all the data chunks in a run
1069   // to be revised whwn it will be used (see MergeData)
1070         TString cmd ;
1071         cmd = Form(".! ls %s*.root > tempo.txt", AliQAv1::GetQADataFileName()) ;
1072         gROOT->ProcessLine(cmd.Data()) ;
1073         ifstream in("tempo.txt") ;
1074         const Int_t chunkMax = 100 ;
1075         TString fileList[chunkMax] ;
1076
1077         Int_t index = 0 ;
1078         while ( 1 ) {
1079                 TString file ;
1080                 in >> fileList[index] ;
1081                 if ( !in.good() )
1082                         break ;
1083                 AliDebug(AliQAv1::GetQADebugLevel(), Form("index = %d file = %s", index, (fileList[index].Data()))) ;
1084                 index++ ;
1085         }
1086
1087         if ( index == 0 ) {
1088                 AliError("No QA Result File found") ;
1089                 return kFALSE ;
1090         }
1091
1092         TFileMerger merger ;
1093   TString outFileName ;
1094   if (runNumber != -1)
1095     outFileName = Form("Merged.%s.Result.%d.root",AliQAv1::GetQADataFileName(),runNumber);
1096   else
1097     outFileName = Form("Merged.%s.Result.root",AliQAv1::GetQADataFileName());
1098         merger.OutputFile(outFileName.Data()) ;
1099         for (Int_t ifile = 0 ; ifile < index ; ifile++) {
1100                 TString file = fileList[ifile] ;
1101                 merger.AddFile(file) ;
1102         }
1103         merger.Merge() ;
1104
1105         return kTRUE ;
1106 }
1107
1108 //_____________________________________________________________________________
1109 void AliQAManager::Reset(const Bool_t sameCycle)
1110 {
1111         // Reset the default data members
1112
1113         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
1114                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
1115                         AliQADataMaker * qadm = GetQADataMaker(iDet);
1116                         if (qadm)
1117         qadm->Reset();
1118                 }
1119         }
1120         if (fRawReaderDelete) {
1121                 delete fRawReader ;
1122                 fRawReader      = NULL ;
1123         }
1124
1125         fCycleSame      = sameCycle ;
1126         fESD            = NULL ;
1127         fESDTree        = NULL ;
1128         //fFirst          = kTRUE ;
1129         fNumberOfEvents = 999999 ;
1130 }
1131
1132 //_____________________________________________________________________________
1133 void AliQAManager::ResetDetectors(AliQAv1::TASKINDEX_t task, AliQAv1::DETECTORINDEX_t det)
1134 {
1135     //calls ResetDetector of specified or all detectors
1136   UInt_t iDet    = 0 ;
1137   UInt_t iDetMax = fgkNDetectors ;
1138   if ( det != AliQAv1::kNULLDET ) {
1139     iDet    = det ;
1140     iDetMax = det+1 ;
1141   }
1142
1143         for (iDet = 0; iDet < iDetMax ; iDet++) {
1144                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
1145                         AliQADataMaker * qadm = GetQADataMaker(iDet);
1146                         qadm->ResetDetector(task);
1147                 }
1148         }
1149 }
1150
1151 //_____________________________________________________________________________
1152 AliQAManager * AliQAManager::QAManager(AliQAv1::MODE_t mode, TMap *entryCache, Int_t run)
1153 {
1154   // returns AliQAManager instance (singleton)
1155
1156         if (!fgQAInstance) {
1157     if ( (mode != AliQAv1::kSIMMODE) && (mode != AliQAv1::kRECMODE) && (mode != AliQAv1::kQAMODE) ) {
1158       AliWarningClass("You must specify kSIMMODE or kRECMODE or kQAMODE") ;
1159       return NULL ;
1160     }
1161     fgQAInstance = new AliQAManager(mode) ;
1162     if (!entryCache)
1163                   fgQAInstance->Init();
1164                 else
1165                   fgQAInstance->InitFromCache(entryCache,run);
1166   }
1167         return fgQAInstance;
1168 }
1169
1170 //_____________________________________________________________________________
1171 AliQAManager * AliQAManager::QAManager(AliQAv1::TASKINDEX_t task)
1172 {
1173   // returns AliQAManager instance (singleton)
1174   return QAManager(AliQAv1::Mode(task)) ;
1175 }
1176
1177 //_____________________________________________________________________________
1178 TString AliQAManager::Run(const Char_t * detectors, AliRawReader * rawReader, const Bool_t sameCycle)
1179 {
1180         //Runs all the QA data Maker for Raws only
1181
1182         fCycleSame       = sameCycle ;
1183         fRawReader       = rawReader ;
1184         fDetectors       = detectors ;
1185         fDetectorsW      = detectors ;
1186
1187         AliCDBManager* man = AliCDBManager::Instance() ;
1188
1189         if ( man->GetRun() == -1 ) {// check if run number not set previously and set it from raw data
1190                 rawReader->NextEvent() ;
1191                 man->SetRun(fRawReader->GetRunNumber()) ;
1192                 rawReader->RewindEvents() ;
1193         }
1194
1195         if (!fCycleSame)
1196     if ( !InitQA(AliQAv1::kRAWS) )
1197       return "" ;
1198   fRawReaderDelete = kFALSE ;
1199
1200         DoIt(AliQAv1::kRAWS) ;
1201         return  fDetectorsW ;
1202 }
1203
1204 //_____________________________________________________________________________
1205 TString AliQAManager::Run(const Char_t * detectors, const Char_t * fileName, const Bool_t sameCycle)
1206 {
1207         //Runs all the QA data Maker for Raws only
1208
1209         fCycleSame       = sameCycle ;
1210         fDetectors       = detectors ;
1211         fDetectorsW      = detectors ;
1212
1213         AliCDBManager* man = AliCDBManager::Instance() ;
1214         if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
1215                 AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
1216                 if ( ! rl ) {
1217                         AliFatal("galice.root file not found in current directory") ;
1218                 } else {
1219                         rl->CdGAFile() ;
1220                         rl->LoadgAlice() ;
1221                         if ( ! rl->GetAliRun() ) {
1222                                 AliFatal("AliRun not found in galice.root") ;
1223                         } else {
1224                                 rl->LoadHeader() ;
1225                                 man->SetRun(rl->GetHeader()->GetRun());
1226                         }
1227                 }
1228         }
1229
1230         if (!fCycleSame)
1231     if ( !InitQA(AliQAv1::kRAWS, fileName) )
1232       return "" ;
1233
1234         DoIt(AliQAv1::kRAWS) ;
1235         return  fDetectorsW ;
1236 }
1237
1238 //_____________________________________________________________________________
1239 TString AliQAManager::Run(const Char_t * detectors, const AliQAv1::TASKINDEX_t taskIndex, Bool_t const sameCycle, const  Char_t * fileName )
1240 {
1241         // Runs all the QA data Maker for every detector
1242
1243         fCycleSame       = sameCycle ;
1244         fDetectors       = detectors ;
1245         fDetectorsW      = detectors ;
1246
1247         AliCDBManager* man = AliCDBManager::Instance() ;
1248         if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
1249                 AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
1250                 if ( ! rl ) {
1251                         AliFatal("galice.root file not found in current directory") ;
1252                 } else {
1253                         rl->CdGAFile() ;
1254                         rl->LoadgAlice() ;
1255                         if ( ! rl->GetAliRun() ) {
1256                                 AliDebug(AliQAv1::GetQADebugLevel(), "AliRun not found in galice.root") ;
1257                         } else {
1258                                 rl->LoadHeader() ;
1259                                 man->SetRun(rl->GetHeader()->GetRun()) ;
1260                         }
1261                 }
1262         }
1263   if ( taskIndex == AliQAv1::kNULLTASKINDEX) {
1264                 for (UInt_t task = 0; task < AliQAv1::kNTASKINDEX; task++) {
1265                         if ( fTasks.Contains(Form("%d", task)) ) {
1266         if (!fCycleSame)
1267           if ( !InitQA(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(task)), fileName) )
1268             return "" ;
1269         DoIt(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(task))) ;
1270                         }
1271                 }
1272         } else {
1273     if (! fCycleSame )
1274       if ( !InitQA(taskIndex, fileName) )
1275         return "" ;
1276       DoIt(taskIndex) ;
1277   }
1278         return fDetectorsW ;
1279 }
1280
1281 //_____________________________________________________________________________
1282 void AliQAManager::RunOneEvent(AliRawReader * rawReader)
1283 {
1284         //Runs all the QA data Maker for Raws only and on one event only (event loop done by calling method)
1285   if ( ! rawReader )
1286     return ;
1287   if (fTasks.Contains(Form("%d", AliQAv1::kRAWS))){
1288     for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1289       if (!IsSelected(AliQAv1::GetDetName(iDet)))
1290         continue;
1291       AliQADataMaker *qadm = GetQADataMaker(iDet);
1292       if (!qadm)
1293         continue;
1294       if ( qadm->IsCycleDone() ) {
1295         qadm->EndOfCycle() ;
1296       }
1297       qadm->SetEventSpecie(fEventSpecie) ;
1298       if ( qadm->GetRecoParam() )
1299         if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
1300           qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
1301                         qadm->Exec(AliQAv1::kRAWS, rawReader) ;
1302                 }
1303   }
1304 }
1305
1306 //_____________________________________________________________________________
1307 void AliQAManager::RunOneEvent(AliESDEvent *& esd, AliESDEvent *& hltesd)
1308 {
1309         //Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
1310
1311   if (fTasks.Contains(Form("%d", AliQAv1::kESDS))) {
1312     for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1313       if (!IsSelected(AliQAv1::GetDetName(iDet)))
1314         continue;
1315       AliQADataMaker *qadm = GetQADataMaker(iDet);
1316       if (!qadm)
1317         continue;
1318       qadm->SetEventSpecie(fEventSpecie) ;
1319       if ( qadm->GetRecoParam() )
1320         if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
1321           qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
1322       if ( qadm->IsCycleDone() ) {
1323         qadm->EndOfCycle() ;
1324       }
1325       if (iDet == AliQAv1::kHLT) {
1326         TObjArray esdarray;
1327         esdarray.Add(esd);
1328         esdarray.Add(hltesd);
1329         qadm->Exec(AliQAv1::kESDS, &esdarray);
1330       } else {
1331         qadm->Exec(AliQAv1::kESDS, esd) ;
1332       }
1333                 }
1334         }
1335 }
1336
1337 //_____________________________________________________________________________
1338 void AliQAManager::RunOneEventInOneDetector(Int_t det, TTree * tree)
1339 {
1340         // Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
1341
1342   TString test(tree->GetName()) ;
1343   if (fTasks.Contains(Form("%d", AliQAv1::kRECPOINTS))) {
1344     if (IsSelected(AliQAv1::GetDetName(det))) {
1345       AliQADataMaker *qadm = GetQADataMaker(det);
1346       if (qadm) {
1347         qadm->SetEventSpecie(fEventSpecie) ;
1348         if ( qadm->GetRecoParam() ) {
1349           if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
1350             qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
1351           else
1352             AliError(Form("%d defined by %s is not an event specie", qadm->GetRecoParam()->GetEventSpecie(), qadm->GetName())) ;
1353         }
1354         if ( qadm->IsCycleDone() ) {
1355           qadm->EndOfCycle() ;
1356         }
1357         if (test.Contains("TreeD")) {
1358           qadm->Exec(AliQAv1::kDIGITSR, tree) ;
1359         } else  if (test.Contains("TreeR")) {
1360           qadm->Exec(AliQAv1::kRECPOINTS, tree) ;
1361         }
1362       }
1363     }
1364   }
1365 }
1366
1367 //_____________________________________________________________________________
1368 Bool_t AliQAManager::Save2OCDB(const Int_t runNumber, AliRecoParam::EventSpecie_t es, const Char_t * year, const Char_t * detectors) const
1369 {
1370         // take the locasl QA data merge into a single file and save in OCDB
1371         Bool_t rv = kTRUE ;
1372         TString tmp(AliQAv1::GetQARefStorage()) ;
1373         if ( tmp.IsNull() ) {
1374                 AliError("No storage defined, use AliQAv1::SetQARefStorage") ;
1375                 return kFALSE ;
1376         }
1377         if ( !(tmp.Contains(AliQAv1::GetLabLocalOCDB()) || tmp.Contains(AliQAv1::GetLabAliEnOCDB())) ) {
1378                 AliError(Form("%s is a wrong storage, use %s or %s", AliQAv1::GetQARefStorage(), AliQAv1::GetLabLocalOCDB().Data(), AliQAv1::GetLabAliEnOCDB().Data())) ;
1379                 return kFALSE ;
1380         }
1381         TString sdet(detectors) ;
1382         sdet.ToUpper() ;
1383         TFile * inputFile ;
1384         if ( sdet.Contains("ALL") ) {
1385                 rv = Merge(runNumber) ;
1386                 if ( ! rv )
1387                         return kFALSE ;
1388                 TString inputFileName(Form("Merged.%s.Data.%d.root", AliQAv1::GetQADataFileName(), runNumber)) ;
1389                 inputFile = TFile::Open(inputFileName.Data()) ;
1390                 rv = SaveIt2OCDB(runNumber, inputFile, year, es) ;
1391         } else {
1392                 for (Int_t index = 0; index < AliQAv1::kNDET; index++) {
1393                         if (sdet.Contains(AliQAv1::GetDetName(index))) {
1394                                 TString inputFileName(Form("%s.%s.%d.root", AliQAv1::GetDetName(index), AliQAv1::GetQADataFileName(), runNumber)) ;
1395                                 inputFile = TFile::Open(inputFileName.Data()) ;
1396                                 rv *= SaveIt2OCDB(runNumber, inputFile, year, es) ;
1397                         }
1398                 }
1399         }
1400         return rv ;
1401 }
1402
1403 //_____________________________________________________________________________
1404 Bool_t AliQAManager::SaveIt2OCDB(const Int_t runNumber, TFile * inputFile, const Char_t * year, AliRecoParam::EventSpecie_t es) const
1405 {
1406         // reads the TH1 from file and adds it to appropriate list before saving to OCDB
1407         Bool_t rv = kTRUE ;
1408         AliDebug(AliQAv1::GetQADebugLevel(), Form("Saving TH1s in %s to %s", inputFile->GetName(), AliQAv1::GetQARefStorage())) ;
1409         if ( ! IsDefaultStorageSet() ) {
1410                 TString tmp( AliQAv1::GetQARefStorage() ) ;
1411                 if ( tmp.Contains(AliQAv1::GetLabLocalOCDB()) )
1412                         Instance()->SetDefaultStorage(AliQAv1::GetQARefStorage()) ;
1413                 else {
1414                         TString tmp1(AliQAv1::GetQARefDefaultStorage()) ;
1415                         tmp1.Append(year) ;
1416                         tmp1.Append("?user=alidaq") ;
1417                         Instance()->SetDefaultStorage(tmp1.Data()) ;
1418                 }
1419         }
1420         Instance()->SetSpecificStorage("*", AliQAv1::GetQARefStorage()) ;
1421         if(GetRun() < 0)
1422                 Instance()->SetRun(runNumber);
1423
1424         AliCDBMetaData mdr ;
1425         mdr.SetResponsible("yves schutz");
1426
1427         for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++) {
1428                 TDirectory * detDir = inputFile->GetDirectory(AliQAv1::GetDetName(detIndex)) ;
1429                 if ( detDir ) {
1430                         AliDebug(AliQAv1::GetQADebugLevel(), Form("Entering %s", detDir->GetName())) ;
1431       AliQAv1::SetQARefDataDirName(es) ;
1432                         TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetDetName(detIndex), AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName())) ;
1433                         AliCDBId idr(detOCDBDir.Data(), runNumber, AliCDBRunRange::Infinity())  ;
1434                         TList * listDetQAD = new TList() ;
1435                         TString listName(Form("%s QA data Reference", AliQAv1::GetDetName(detIndex))) ;
1436                         mdr.SetComment(Form("%s QA stuff", AliQAv1::GetDetName(detIndex)));
1437                         listDetQAD->SetName(listName) ;
1438                         TList * taskList = detDir->GetListOfKeys() ;
1439                         TIter nextTask(taskList) ;
1440                         TKey * taskKey ;
1441                         while ( (taskKey = static_cast<TKey*>(nextTask())) ) {
1442                                 TDirectory * taskDir = detDir->GetDirectory(taskKey->GetName()) ;
1443         TDirectory * esDir   = taskDir->GetDirectory(AliRecoParam::GetEventSpecieName(es)) ;
1444                                 AliDebug(AliQAv1::GetQADebugLevel(), Form("Saving %s", esDir->GetName())) ;
1445                                 TObjArray * listTaskQAD = new TObjArray(100) ;
1446                                 listTaskQAD->SetName(Form("%s/%s", taskKey->GetName(), AliRecoParam::GetEventSpecieName(es))) ;
1447                                 listDetQAD->Add(listTaskQAD) ;
1448                                 TList * histList = esDir->GetListOfKeys() ;
1449                                 TIter nextHist(histList) ;
1450                                 TKey * histKey ;
1451                                 while ( (histKey = static_cast<TKey*>(nextHist())) ) {
1452                                         TObject * odata = esDir->Get(histKey->GetName()) ;
1453                                         if ( !odata ) {
1454                                                 AliError(Form("%s in %s/%s returns a NULL pointer !!", histKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
1455                                         } else {
1456             if ( AliQAv1::GetExpert() == histKey->GetName() ) {
1457               TDirectory * expertDir   = esDir->GetDirectory(histKey->GetName()) ;
1458               TList * expertHistList = expertDir->GetListOfKeys() ;
1459               TIter nextExpertHist(expertHistList) ;
1460               TKey * expertHistKey ;
1461               while ( (expertHistKey = static_cast<TKey*>(nextExpertHist())) ) {
1462                 TObject * expertOdata = expertDir->Get(expertHistKey->GetName()) ;
1463                 if ( !expertOdata ) {
1464                   AliError(Form("%s in %s/%s/Expert returns a NULL pointer !!", expertHistKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
1465                 } else {
1466                   AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", expertHistKey->GetName())) ;
1467                   if ( expertOdata->IsA()->InheritsFrom("TH1") ) {
1468                     AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", expertHistKey->GetName())) ;
1469                     TH1 * hExpertdata = static_cast<TH1*>(expertOdata) ;
1470                     listTaskQAD->Add(hExpertdata) ;
1471                   }
1472                 }
1473               }
1474             }
1475                                                 AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", histKey->GetName())) ;
1476                                                 if ( odata->IsA()->InheritsFrom("TH1") ) {
1477                                                         AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", histKey->GetName())) ;
1478                                                         TH1 * hdata = static_cast<TH1*>(odata) ;
1479                                                         listTaskQAD->Add(hdata) ;
1480                                                 }
1481                                         }
1482                                 }
1483                         }
1484                         Instance()->Put(listDetQAD, idr, &mdr) ;
1485                 }
1486         }
1487         return rv ;
1488 }
1489
1490 //_____________________________________________________________________________
1491
1492 void AliQAManager::SetCheckerExternParam(AliQAv1::DETECTORINDEX_t detIndex, TList * parameterList)
1493 {
1494   // set the external parameters list for the detector checkers
1495   AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(detIndex) ;
1496   qac->SetExternParamlist(parameterList) ;
1497   qac->PrintExternParam() ;
1498 }
1499
1500 //_____________________________________________________________________________
1501 void AliQAManager::SetEventSpecie(AliRecoParam::EventSpecie_t es)
1502 {
1503   // set the current event specie and inform AliQAv1 that this event specie has been encountered
1504   fEventSpecie = es ;
1505   AliQAv1::Instance()->SetEventSpecie(es) ;
1506 }
1507
1508 //_____________________________________________________________________________
1509 void AliQAManager::SetRecoParam(const Int_t det, const AliDetectorRecoParam *par)
1510 {
1511   // Set custom reconstruction parameters for a given detector
1512   // Single set of parameters for all the events
1513   GetQADataMaker(det)->SetRecoParam(par) ;
1514 }
1515
1516 //_____________________________________________________________________________
1517 void AliQAManager::SetWriteExpert()
1518 {
1519   // enable the writing of QA expert data
1520   for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1521         if (IsSelected(AliQAv1::GetDetName(iDet)))
1522       fQAWriteExpert[iDet] = kTRUE ;
1523   }
1524 }
1525
1526 //_____________________________________________________________________________
1527 void AliQAManager::Destroy() {
1528   // delete AliQAManager instance and
1529   // all associated objects
1530
1531   if (fgQAInstance) {
1532     delete fgQAInstance ;
1533     fgQAInstance = NULL ;
1534   }
1535 }
1536
1537 //_____________________________________________________________________________
1538 void AliQAManager::ShowQA() {
1539   // Show the result of the QA checking
1540   // for all detectors
1541         for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++)
1542     AliQAv1::Instance(AliQAv1::GetDetIndex(AliQAv1::GetDetName(detIndex)))->Show() ;
1543 }