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