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