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       for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
 548         if ( fTasks.Contains(Form("%d", taskIndex)) )
 549           qadm->EndOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex))) ;
 550       }
 551                         qadm->Finish();
 552                 }
 553         }
 554 }
 555
 556 //_____________________________________________________________________________
 557 void  AliQAManager::EndOfCycle(TString detectors)
 558 {
 559         // End of cycle QADataMakers
 560
 561   AliQAChecker::Instance()->SetRunNumber(fRunNumber) ;
 562   if (fPrintImage) {
 563     TCanvas fakeCanvas ;
 564     fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ;
 565   }
 566   for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 567                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
 568                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 569       AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(iDet) ;
 570                         if (!qadm)
 571                                 continue ;
 572                         // skip non active detectors
 573       if (!detectors.Contains(AliQAv1::GetDetName(iDet)))
 574         continue ;
 575       if (qac)
 576         qac->SetPrintImage(fPrintImage) ;
 577       for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
 578         if ( fTasks.Contains(Form("%d", taskIndex)) )
 579           qadm->EndOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex))) ;
 580       }
 581                         qadm->Finish();
 582                 }
 583         }
 584 }
 585
 586 //_____________________________________________________________________________
 587 void AliQAManager::Increment(const AliQAv1::TASKINDEX_t taskIndex)
 588 {
 589   // Increments the cycle counter for all QA Data Makers
 590   static AliQAv1::TASKINDEX_t currentTask = AliQAv1::kNTASKINDEX ;
 591   if (currentTask == taskIndex)
 592     return ;
 593   else
 594     currentTask = taskIndex ;
 595         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 596                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
 597                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 598                         if (qadm)
 599         qadm->Increment() ;
 600     }
 601   }
 602 }
 603
 604 //_____________________________________________________________________________
 605 Bool_t AliQAManager::InitQA(const AliQAv1::TASKINDEX_t taskIndex, const  Char_t * input )
 606 {
 607         // Initialize the event source and QA data makers
 608
 609         fTasks += Form("%d", taskIndex) ;
 610
 611         if (taskIndex == AliQAv1::kRAWS) {
 612                 if (!fRawReader) {
 613                         fRawReader = AliRawReader::Create(input);
 614                 }
 615                 if ( ! fRawReader )
 616                         return kFALSE ;
 617                 fRawReaderDelete = kTRUE ;
 618                 fRawReader->NextEvent() ;
 619                 fRunNumber = fRawReader->GetRunNumber() ;
 620                 SetRun(fRunNumber) ;
 621                 fRawReader->RewindEvents();
 622                 fNumberOfEvents = 999999 ;
 623                 if ( fMaxEvents < 0 )
 624                         fMaxEvents = fNumberOfEvents ;
 625                 } else if (taskIndex == AliQAv1::kESDS) {
 626                         fTasks = AliQAv1::GetTaskName(AliQAv1::kESDS) ;
 627       if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
 628         TFile * esdFile = TFile::Open("AliESDs.root") ;
 629         fESDTree = static_cast<TTree *> (esdFile->Get("esdTree")) ;
 630         if ( !fESDTree ) {
 631           AliError("esdTree not found") ;
 632           return kFALSE ;
 633         } else {
 634           fESD     = new AliESDEvent() ;
 635           fESD->ReadFromTree(fESDTree) ;
 636           fESDTree->GetEntry(0) ;
 637           fRunNumber = fESD->GetRunNumber() ;
 638           fNumberOfEvents = fESDTree->GetEntries() ;
 639           if ( fMaxEvents < 0 )
 640             fMaxEvents = fNumberOfEvents ;
 641         }
 642       } else {
 643         AliError("AliESDs.root not found") ;
 644         return kFALSE ;
 645       }
 646     } else {
 647       if ( !InitRunLoader() ) {
 648         AliWarning("No Run Loader not found") ;
 649       } else {
 650         fNumberOfEvents = fRunLoader->GetNumberOfEvents() ;
 651         if ( fMaxEvents < 0 )
 652           fMaxEvents = fNumberOfEvents ;
 653       }
 654     }
 655
 656   // Get Detectors
 657   TObjArray* detArray = NULL ;
 658         if (fRunLoader) // check if RunLoader exists
 659                 if ( fRunLoader->GetAliRun() ) { // check if AliRun exists in gAlice.root
 660                         detArray = fRunLoader->GetAliRun()->Detectors() ;
 661                         fRunNumber = fRunLoader->GetHeader()->GetRun() ;
 662                 }
 663
 664         // Initialize all QA data makers for all detectors
 665         fRunNumber = AliCDBManager::Instance()->GetRun() ;
 666         if ( !  AliGeomManager::GetGeometry() )
 667                 AliGeomManager::LoadGeometry() ;
 668
 669         InitQADataMaker(fRunNumber, detArray) ; //, fCycleSame, kTRUE, detArray) ;
 670   if (fPrintImage) {
 671     TCanvas fakeCanvas ;
 672     TStopwatch timer ;
 673     timer.Start() ;
 674     while (timer.CpuTime()<5) {
 675       timer.Continue();
 676       gSystem->ProcessEvents();
 677     }
 678     fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ;
 679   }
 680         return kTRUE ;
 681 }
 682
 683 //_____________________________________________________________________________
 684 void  AliQAManager::InitQADataMaker(UInt_t run, TObjArray * detArray)
 685 {
 686         // Initializes The QADataMaker for all active detectors and for all active tasks
 687   fRunNumber = run ;
 688         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 689                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
 690                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 691                         if (!qadm) {
 692                                 AliError(Form("AliQADataMaker not found for %s", AliQAv1::GetDetName(iDet))) ;
 693                                 fDetectorsW.ReplaceAll(AliQAv1::GetDetName(iDet), "") ;
 694                         } else {
 695         if (fQAWriteExpert[iDet])
 696           qadm->SetWriteExpert() ;
 697                                 AliDebug(AliQAv1::GetQADebugLevel(), Form("Data Maker found for %s %d", qadm->GetName(), qadm->WriteExpert())) ;
 698                                 // skip non active detectors
 699                                 if (detArray) {
 700                                         AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQAv1::GetDetName(iDet))) ;
 701                                         if (!det || !det->IsActive())
 702                                                 continue ;
 703                                 }
 704               // Set default reco params
 705         Bool_t sameCycle = kFALSE ;
 706                                 for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
 707                                         if ( fTasks.Contains(Form("%d", taskIndex)) ) {
 708                                                 qadm->Init(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), GetQACycles(qadm->GetUniqueID())) ;
 709             qadm->StartOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), run,  sameCycle) ;
 710             sameCycle = kTRUE ;
 711                                         }
 712                                 }
 713                         }
 714                 }
 715         }
 716 }
 717
 718
 719 //_____________________________________________________________________________
 720 Bool_t AliQAManager::InitRunLoader()
 721 {
 722         // get or create the run loader
 723         if (fRunLoader) {
 724                 fCycleSame = kTRUE ;
 725         } else {
 726                 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
 727                         // load all base libraries to get the loader classes
 728                         TString libs = gSystem->GetLibraries() ;
 729                         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 730                                 if (!IsSelected(AliQAv1::GetDetName(iDet)))
 731                                         continue ;
 732                                 TString detName = AliQAv1::GetDetName(iDet) ;
 733                                 if (detName == "HLT")
 734                                         continue;
 735                                 if (libs.Contains("lib" + detName + "base.so"))
 736                                         continue;
 737                                 gSystem->Load("lib" + detName + "base.so");
 738                         }
 739                         fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
 740                         if (!fRunLoader) {
 741                                 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
 742                                 return kFALSE;
 743                         }
 744                         fRunLoader->CdGAFile();
 745                         if (fRunLoader->LoadgAlice() == 0) {
 746                                 gAlice = fRunLoader->GetAliRun();
 747                         }
 748
 749                         if (!gAlice) {
 750                                 AliError(Form("no gAlice object found in file %s", fGAliceFileName.Data()));
 751                                 return kFALSE;
 752                         }
 753
 754                 } else {               // galice.root does not exist
 755                         AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
 756                         return kFALSE;
 757                 }
 758         }
 759
 760         if (!fRunNumber) {
 761                 fRunLoader->LoadHeader();
 762                 fRunNumber = fRunLoader->GetHeader()->GetRun() ;
 763         }
 764         return kTRUE;
 765 }
 766
 767 //_____________________________________________________________________________
 768 Bool_t AliQAManager::IsSelected(const Char_t * det)
 769 {
 770   // check whether detName is contained in detectors
 771         // if yes, it is removed from detectors
 772
 773         Bool_t rv = kFALSE;
 774         const TString detName(det) ;
 775   // always activates Correlation
 776   if ( detName.Contains(AliQAv1::GetDetName(AliQAv1::kCORR)) || detName.Contains(AliQAv1::GetDetName(AliQAv1::kGLOBAL))) {
 777     rv = kTRUE ;
 778   } else {
 779     // check if all detectors are selected
 780     if (fDetectors.Contains("ALL")) {
 781       fDetectors = "ALL";
 782       rv = kTRUE;
 783     } else if ((fDetectors.CompareTo(detName) == 0) ||
 784                fDetectors.BeginsWith(detName+" ") ||
 785                fDetectors.EndsWith(" "+detName) ||
 786                fDetectors.Contains(" "+detName+" ")) {
 787       rv = kTRUE;
 788     }
 789   }
 790         return rv ;
 791 }
 792
 793 //_____________________________________________________________________________
 794 Bool_t AliQAManager::Merge(Int_t runNumber, const char *fileName) const
 795 {
 796         // Merge data from all detectors from a given run in one single file
 797         // Merge the QA results from all the data chunks in one run
 798   // The 'fileName' is name of the output file with merged QA data
 799  if ( runNumber == -1)
 800    runNumber = fRunNumber ;
 801  Bool_t rv = MergeData(runNumber,fileName) ;
 802  //rv *= MergeResults(runNumber) ; // not needed for the time being
 803  return rv ;
 804 }
 805
 806 //______________________________________________________________________
 807 Bool_t AliQAManager::MergeXML(const Char_t * collectionFile, const Char_t * subFile, const Char_t * outFile)
 808 {
 809   // merges files listed in a xml collection
 810   // usage Merge(collection, outputFile))
 811   //              collection: is a xml collection
 812
 813   Bool_t rv = kFALSE ;
 814
 815   if ( strstr(collectionFile, ".xml") == 0 ) {
 816     AliError("Input collection file must be an \".xml\" file\n") ;
 817     return kFALSE ;
 818   }
 819
 820  if ( !gGrid )
 821    TGrid::Connect("alien://");
 822  if ( !gGrid )
 823    return kFALSE ;
 824
 825   // Open the file collection
 826   AliInfoClass(Form("*** Create Collection       ***\n***  Wk-Dir = |%s|             \n***  Coll   = |%s|             \n",gSystem->WorkingDirectory(), collectionFile));
 827
 828   TGridCollection * collection = (TGridCollection*)gROOT->ProcessLine(Form("TAlienCollection::Open(\"%s\")",collectionFile));
 829   TGridResult* result = collection->GetGridResult("", 0, 0);
 830
 831   Int_t index = 0  ;
 832   const Char_t * turl ;
 833   TFileMerger merger(kFALSE) ;
 834   if (!outFile) {
 835     TString tempo(collectionFile) ;
 836     if ( subFile)
 837       tempo.ReplaceAll(".xml", subFile) ;
 838     else
 839       tempo.ReplaceAll(".xml", "_Merged.root") ;
 840     outFile = tempo.Data() ;
 841   }
 842   merger.OutputFile(outFile) ;
 843
 844   while ( (turl = result->GetKey(index, "turl")) ) {
 845     Char_t * file ;
 846     if ( subFile )
 847       file = Form("%s#%s", turl, subFile) ;
 848     else
 849       file = Form("%s", turl) ;
 850
 851     AliDebug(AliQAv1::GetQADebugLevel(), Form("%s\n", file)) ;
 852     merger.AddFile(file) ;
 853     index++ ;
 854   }
 855
 856   if (index)
 857     merger.Merge() ;
 858
 859   AliDebug(AliQAv1::GetQADebugLevel(), Form("Files merged into %s\n", outFile)) ;
 860
 861   rv = kFALSE;
 862   return rv ;
 863 }
 864
 865 //_____________________________________________________________________________
 866 void AliQAManager::MergeCustom() const
 867 {
 868         // Custom Merge of QA data from all detectors for all runs in one single file
 869   // search all the run numbers
 870   // search all the run numbers
 871   gROOT->ProcessLine(".! ls *QA*.root > QAtempo.txt") ;
 872   TString QAfile ;
 873   FILE * QAfiles = fopen("QAtempo.txt", "r") ;
 874   Int_t index = 0 ;
 875   TList srunList ;
 876   TIter nextRun(&srunList) ;
 877   TObjString * srun = NULL ;
 878   Int_t loRun = 999999999 ;
 879   Int_t hiRun = 0 ;
 880   while ( QAfile.Gets(QAfiles) ) {
 881     Bool_t runExist = kFALSE ;
 882     TString srunNew(QAfile(QAfile.Index("QA.")+3, QAfile.Index(".root")-(QAfile.Index("QA.")+3))) ;
 883     Int_t cuRun = srunNew.Atoi() ;
 884     if (cuRun < loRun)
 885       loRun = cuRun ;
 886     if (cuRun > hiRun)
 887       hiRun = cuRun ;
 888     while ( (srun = static_cast<TObjString *> (nextRun())) ) {
 889       if ( cuRun == (srun->String()).Atoi() ) {
 890         runExist = kTRUE ;
 891         break ;
 892       }
 893     }
 894     nextRun.Reset() ;
 895     if ( ! runExist )
 896       srunList.Add(new TObjString(srunNew.Data()));
 897   }
 898   nextRun.Reset() ;
 899   Int_t runNumber = 0 ;
 900   TFile mergedFile(Form("Merged.%s.Data.root", AliQAv1::GetQADataFileName()), "RECREATE") ;
 901   TH1I * hisRun = new TH1I("hLMR", "List of merged runs", hiRun-loRun+10, loRun, hiRun+10) ;
 902   // create the structure into the merged file
 903   for (Int_t iDet = 0; iDet < AliQAv1::kNDET ; iDet++) {
 904     TDirectory * detDir = mergedFile.mkdir(AliQAv1::GetDetName(iDet)) ;
 905     for (Int_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
 906       detDir->cd() ;
 907       TDirectory * taskDir = gDirectory->mkdir(AliQAv1::GetTaskName(taskIndex)) ;
 908       for (Int_t es = 0 ; es < AliRecoParam::kNSpecies ; es++) {
 909         taskDir->cd() ;
 910         TDirectory * esDir = gDirectory->mkdir(AliRecoParam::GetEventSpecieName(es)) ;
 911         esDir->cd() ;
 912         gDirectory->mkdir(AliQAv1::GetExpert()) ;
 913       }
 914     }
 915   }
 916   while ( (srun = static_cast<TObjString *> (nextRun())) ) {
 917     runNumber = (srun->String()).Atoi() ;
 918     hisRun->Fill(runNumber) ;
 919     AliDebug(AliQAv1::GetQADebugLevel(), Form("Merging run number %d", runNumber)) ;
 920     // search all QA files for runNumber in the current directory
 921     Char_t * fileList[AliQAv1::kNDET] ;
 922     index = 0 ;
 923     for (Int_t iDet = 0; iDet < AliQAv1::kNDET ; iDet++) {
 924       Char_t * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQAv1::GetDetName(iDet), AliQAv1::GetQADataFileName(), runNumber));
 925       if (file)
 926         fileList[index++] = file ;
 927     }
 928     if ( index == 0 ) {
 929       AliError("No QA data file found\n") ;
 930       return ;
 931     }
 932     for ( Int_t i = 0 ; i < index ; i++) {
 933       TFile * inFile = TFile::Open(fileList[i]) ;
 934       TList * listOfKeys =inFile->GetListOfKeys() ;
 935       TIter nextkey(listOfKeys) ;
 936       TObject * obj1 ;
 937       TString dirName("") ;
 938       while ( (obj1 = nextkey()) ) {
 939         TDirectory * directoryDet = inFile->GetDirectory(obj1->GetName()) ;
 940         if ( directoryDet ) {
 941           AliDebug(AliQAv1::GetQADebugLevel(), Form("%s dir = %s", inFile->GetName(), directoryDet->GetName())) ;
 942           dirName += Form("%s/", directoryDet->GetName() ) ;
 943           directoryDet->cd() ;
 944           TList * listOfTasks = directoryDet->GetListOfKeys() ;
 945           TIter nextTask(listOfTasks) ;
 946           TObject * obj2 ;
 947           while ( (obj2 = nextTask()) ) {
 948             TDirectory * directoryTask = directoryDet->GetDirectory(obj2->GetName()) ;
 949             if ( directoryTask ) {
 950               dirName += Form("%s", obj2->GetName()) ;
 951               AliDebug(AliQAv1::GetQADebugLevel(), Form("%s", dirName.Data())) ;
 952               directoryTask->cd() ;
 953               TList * listOfEventSpecie = directoryTask->GetListOfKeys() ;
 954               TIter nextEventSpecie(listOfEventSpecie) ;
 955               TObject * obj3 ;
 956               while ( (obj3 = nextEventSpecie()) ) {
 957                 TDirectory * directoryEventSpecie = directoryTask->GetDirectory(obj3->GetName()) ;
 958                 if ( directoryEventSpecie ) {
 959                   dirName += Form("/%s/", obj3->GetName()) ;
 960                   AliDebug(AliQAv1::GetQADebugLevel(), Form("%s\n", dirName.Data())) ;
 961                   directoryEventSpecie->cd() ;
 962                   // histograms are here
 963                   TDirectory * mergedDirectory = mergedFile.GetDirectory(dirName.Data()) ;
 964                   TList * listOfData = directoryEventSpecie->GetListOfKeys() ;
 965                   TIter nextData(listOfData) ;
 966                   TKey * key ;
 967                   while ( (key = static_cast<TKey *>(nextData())) ) {
 968                     TString className(key->GetClassName()) ;
 969                     if (  className.Contains("TH") || className.Contains("TProfile") ) {
 970                       TH1 * histIn = static_cast<TH1*> (key->ReadObj()) ;
 971                       TH1 * histOu = static_cast<TH1*> (mergedDirectory->FindObjectAny(histIn->GetName())) ;
 972                       AliDebug(AliQAv1::GetQADebugLevel(), Form("%s %x %x\n", key->GetName(), histIn, histOu)) ;
 973                       mergedDirectory->cd() ;
 974                       if ( ! histOu ) {
 975                         histIn->Write() ;
 976                       } else {
 977                         histOu->Add(histIn) ;
 978                         histOu->Write(histOu->GetName(), kOverwrite) ;
 979                       }
 980                     }
 981                     else if ( className.Contains("TDirectoryFile") ) {
 982                       TDirectory * dirExpert = directoryEventSpecie->GetDirectory(key->GetName()) ;
 983                       dirExpert->cd() ;
 984                       TDirectory * mergedDirectoryExpert = mergedDirectory->GetDirectory(dirExpert->GetName()) ;
 985                       TList * listOfExpertData = dirExpert->GetListOfKeys() ;
 986                       TIter nextExpertData(listOfExpertData) ;
 987                       TKey * keykey ;
 988                       while ( (keykey = static_cast<TKey *>(nextExpertData())) ) {
 989                         TString classNameExpert(keykey->GetClassName()) ;
 990                         if (classNameExpert.Contains("TH")) {
 991                           TH1 * histInExpert = static_cast<TH1*> (keykey->ReadObj()) ;
 992                           TH1 * histOuExpert = static_cast<TH1*> (mergedDirectory->FindObjectAny(histInExpert->GetName())) ;
 993                           mergedDirectoryExpert->cd() ;
 994                           if ( ! histOuExpert ) {
 995                             histInExpert->Write() ;
 996                           } else {
 997                             histOuExpert->Add(histInExpert) ;
 998                             histOuExpert->Write(histOuExpert->GetName(), kOverwrite) ;
 999                           }
1000                         }
1001                       }
1002                     } else {
1003                       AliError(Form("No merge done for this object %s in %s", key->GetName(), dirName.Data())) ;
1004                     }
1005                   }
1006                   dirName.ReplaceAll(Form("/%s/",obj3->GetName()), "") ;
1007                 }
1008               }
1009               dirName.ReplaceAll(obj2->GetName(), "") ;
1010             }
1011           }
1012         }
1013       }
1014       inFile->Close() ;
1015     }
1016   }
1017   mergedFile.cd() ;
1018   hisRun->Write() ;
1019   mergedFile.Close() ;
1020   srunList.Delete() ;
1021 }
1022
1023 //_____________________________________________________________________________
1024 Bool_t AliQAManager::MergeData(const Int_t runNumber, const char *fileName) const
1025 {
1026         // Merge QA data from all detectors for a given run in one single file
1027
1028   TFileMerger merger(kFALSE) ;
1029   TString outFileName = fileName;
1030   if (outFileName.IsNull()) outFileName.Form("Merged.%s.Data.root",AliQAv1::GetQADataFileName());
1031   merger.OutputFile(outFileName.Data()) ;
1032   for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
1033     Char_t * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQAv1::GetDetName(iDet), AliQAv1::GetQADataFileName(), runNumber));
1034     if (file)
1035       merger.AddFile(file) ;
1036   }
1037   merger.Merge() ;
1038         return kTRUE ;
1039 }
1040
1041 //_____________________________________________________________________________
1042 Bool_t AliQAManager::MergeResults(const Int_t runNumber) const
1043 {
1044         // Merge the QA result from all the data chunks in a run
1045   // to be revised whwn it will be used (see MergeData)
1046         TString cmd ;
1047         cmd = Form(".! ls %s*.root > tempo.txt", AliQAv1::GetQADataFileName()) ;
1048         gROOT->ProcessLine(cmd.Data()) ;
1049         ifstream in("tempo.txt") ;
1050         const Int_t chunkMax = 100 ;
1051         TString fileList[chunkMax] ;
1052
1053         Int_t index = 0 ;
1054         while ( 1 ) {
1055                 TString file ;
1056                 in >> fileList[index] ;
1057                 if ( !in.good() )
1058                         break ;
1059                 AliDebug(AliQAv1::GetQADebugLevel(), Form("index = %d file = %s", index, (fileList[index].Data()))) ;
1060                 index++ ;
1061         }
1062
1063         if ( index == 0 ) {
1064                 AliError("No QA Result File found") ;
1065                 return kFALSE ;
1066         }
1067
1068         TFileMerger merger ;
1069   TString outFileName ;
1070   if (runNumber != -1)
1071     outFileName = Form("Merged.%s.Result.%d.root",AliQAv1::GetQADataFileName(),runNumber);
1072   else
1073     outFileName = Form("Merged.%s.Result.root",AliQAv1::GetQADataFileName());
1074         merger.OutputFile(outFileName.Data()) ;
1075         for (Int_t ifile = 0 ; ifile < index ; ifile++) {
1076                 TString file = fileList[ifile] ;
1077                 merger.AddFile(file) ;
1078         }
1079         merger.Merge() ;
1080
1081         return kTRUE ;
1082 }
1083
1084 //_____________________________________________________________________________
1085 void AliQAManager::Reset(const Bool_t sameCycle)
1086 {
1087         // Reset the default data members
1088
1089         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
1090                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
1091                         AliQADataMaker * qadm = GetQADataMaker(iDet);
1092                         qadm->Reset();
1093                 }
1094         }
1095         if (fRawReaderDelete) {
1096                 delete fRawReader ;
1097                 fRawReader      = NULL ;
1098         }
1099
1100         fCycleSame      = sameCycle ;
1101         fESD            = NULL ;
1102         fESDTree        = NULL ;
1103         //fFirst          = kTRUE ;
1104         fNumberOfEvents = 999999 ;
1105 }
1106
1107 //_____________________________________________________________________________
1108 AliQAManager * AliQAManager::QAManager(AliQAv1::MODE_t mode, TMap *entryCache, Int_t run)
1109 {
1110   // returns AliQAManager instance (singleton)
1111
1112         if (!fgQAInstance) {
1113     if ( (mode != AliQAv1::kSIMMODE) && (mode != AliQAv1::kRECMODE) ) {
1114       AliErrorClass("You must specify kSIMMODE or kRECMODE") ;
1115       return NULL ;
1116     }
1117     fgQAInstance = new AliQAManager(mode) ;
1118     if (!entryCache)
1119                   fgQAInstance->Init();
1120                 else
1121                   fgQAInstance->InitFromCache(entryCache,run);
1122   }
1123         return fgQAInstance;
1124 }
1125
1126 //_____________________________________________________________________________
1127 AliQAManager * AliQAManager::QAManager(AliQAv1::TASKINDEX_t task)
1128 {
1129   // returns AliQAManager instance (singleton)
1130   return QAManager(AliQAv1::Mode(task)) ;
1131 }
1132
1133 //_____________________________________________________________________________
1134 TString AliQAManager::Run(const Char_t * detectors, AliRawReader * rawReader, const Bool_t sameCycle)
1135 {
1136         //Runs all the QA data Maker for Raws only
1137
1138         fCycleSame       = sameCycle ;
1139         fRawReader       = rawReader ;
1140         fDetectors       = detectors ;
1141         fDetectorsW      = detectors ;
1142
1143         AliCDBManager* man = AliCDBManager::Instance() ;
1144
1145         if ( man->GetRun() == -1 ) {// check if run number not set previously and set it from raw data
1146                 rawReader->NextEvent() ;
1147                 man->SetRun(fRawReader->GetRunNumber()) ;
1148                 rawReader->RewindEvents() ;
1149         }
1150
1151         if (!fCycleSame)
1152     if ( !InitQA(AliQAv1::kRAWS) )
1153       return "" ;
1154   fRawReaderDelete = kFALSE ;
1155
1156         DoIt(AliQAv1::kRAWS) ;
1157         return  fDetectorsW ;
1158 }
1159
1160 //_____________________________________________________________________________
1161 TString AliQAManager::Run(const Char_t * detectors, const Char_t * fileName, const Bool_t sameCycle)
1162 {
1163         //Runs all the QA data Maker for Raws only
1164
1165         fCycleSame       = sameCycle ;
1166         fDetectors       = detectors ;
1167         fDetectorsW      = detectors ;
1168
1169         AliCDBManager* man = AliCDBManager::Instance() ;
1170         if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
1171                 AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
1172                 if ( ! rl ) {
1173                         AliFatal("galice.root file not found in current directory") ;
1174                 } else {
1175                         rl->CdGAFile() ;
1176                         rl->LoadgAlice() ;
1177                         if ( ! rl->GetAliRun() ) {
1178                                 AliFatal("AliRun not found in galice.root") ;
1179                         } else {
1180                                 rl->LoadHeader() ;
1181                                 man->SetRun(rl->GetHeader()->GetRun());
1182                         }
1183                 }
1184         }
1185
1186         if (!fCycleSame)
1187     if ( !InitQA(AliQAv1::kRAWS, fileName) )
1188       return "" ;
1189
1190         DoIt(AliQAv1::kRAWS) ;
1191         return  fDetectorsW ;
1192 }
1193
1194 //_____________________________________________________________________________
1195 TString AliQAManager::Run(const Char_t * detectors, const AliQAv1::TASKINDEX_t taskIndex, Bool_t const sameCycle, const  Char_t * fileName )
1196 {
1197         // Runs all the QA data Maker for every detector
1198
1199         fCycleSame       = sameCycle ;
1200         fDetectors       = detectors ;
1201         fDetectorsW      = detectors ;
1202
1203         AliCDBManager* man = AliCDBManager::Instance() ;
1204         if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
1205                 AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
1206                 if ( ! rl ) {
1207                         AliFatal("galice.root file not found in current directory") ;
1208                 } else {
1209                         rl->CdGAFile() ;
1210                         rl->LoadgAlice() ;
1211                         if ( ! rl->GetAliRun() ) {
1212                                 AliDebug(AliQAv1::GetQADebugLevel(), "AliRun not found in galice.root") ;
1213                         } else {
1214                                 rl->LoadHeader() ;
1215                                 man->SetRun(rl->GetHeader()->GetRun()) ;
1216                         }
1217                 }
1218         }
1219   if ( taskIndex == AliQAv1::kNULLTASKINDEX) {
1220                 for (UInt_t task = 0; task < AliQAv1::kNTASKINDEX; task++) {
1221                         if ( fTasks.Contains(Form("%d", task)) ) {
1222         if (!fCycleSame)
1223           if ( !InitQA(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(task)), fileName) )
1224             return "" ;
1225         DoIt(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(task))) ;
1226                         }
1227                 }
1228         } else {
1229     if (! fCycleSame )
1230       if ( !InitQA(taskIndex, fileName) )
1231         return "" ;
1232       DoIt(taskIndex) ;
1233   }
1234         return fDetectorsW ;
1235 }
1236
1237 //_____________________________________________________________________________
1238 void AliQAManager::RunOneEvent(AliRawReader * rawReader)
1239 {
1240         //Runs all the QA data Maker for Raws only and on one event only (event loop done by calling method)
1241   if ( ! rawReader )
1242     return ;
1243   if (fTasks.Contains(Form("%d", AliQAv1::kRAWS))){
1244     for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1245       if (!IsSelected(AliQAv1::GetDetName(iDet)))
1246         continue;
1247       AliQADataMaker *qadm = GetQADataMaker(iDet);
1248       if (!qadm)
1249         continue;
1250       if ( qadm->IsCycleDone() ) {
1251         qadm->EndOfCycle() ;
1252       }
1253       qadm->SetEventSpecie(fEventSpecie) ;
1254       if ( qadm->GetRecoParam() )
1255         if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
1256           qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
1257                         qadm->Exec(AliQAv1::kRAWS, rawReader) ;
1258                 }
1259   }
1260 }
1261
1262 //_____________________________________________________________________________
1263 void AliQAManager::RunOneEvent(AliESDEvent *& esd)
1264 {
1265         //Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
1266
1267   if (fTasks.Contains(Form("%d", AliQAv1::kESDS))) {
1268     for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1269       if (!IsSelected(AliQAv1::GetDetName(iDet)))
1270         continue;
1271       AliQADataMaker *qadm = GetQADataMaker(iDet);
1272       if (!qadm)
1273         continue;
1274       qadm->SetEventSpecie(fEventSpecie) ;
1275       if ( qadm->GetRecoParam() )
1276         if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
1277           qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
1278       if ( qadm->IsCycleDone() ) {
1279         qadm->EndOfCycle() ;
1280       }
1281                         qadm->Exec(AliQAv1::kESDS, esd) ;
1282                 }
1283         }
1284 }
1285
1286 //_____________________________________________________________________________
1287 void AliQAManager::RunOneEventInOneDetector(Int_t det, TTree * tree)
1288 {
1289         // Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
1290
1291   TString test(tree->GetName()) ;
1292   if (fTasks.Contains(Form("%d", AliQAv1::kRECPOINTS))) {
1293     if (IsSelected(AliQAv1::GetDetName(det))) {
1294       AliQADataMaker *qadm = GetQADataMaker(det);
1295       if (qadm) {
1296         qadm->SetEventSpecie(fEventSpecie) ;
1297         if ( qadm->GetRecoParam() ) {
1298           if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
1299             qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
1300           else
1301             AliError(Form("%d defined by %s is not an event specie", qadm->GetRecoParam()->GetEventSpecie(), qadm->GetName())) ;
1302         }
1303         if ( qadm->IsCycleDone() ) {
1304           qadm->EndOfCycle() ;
1305         }
1306         if (test.Contains("TreeD")) {
1307           qadm->Exec(AliQAv1::kDIGITSR, tree) ;
1308         } else  if (test.Contains("TreeR")) {
1309           qadm->Exec(AliQAv1::kRECPOINTS, tree) ;
1310         }
1311       }
1312     }
1313   }
1314 }
1315
1316 //_____________________________________________________________________________
1317 Bool_t AliQAManager::Save2OCDB(const Int_t runNumber, AliRecoParam::EventSpecie_t es, const Char_t * year, const Char_t * detectors) const
1318 {
1319         // take the locasl QA data merge into a single file and save in OCDB
1320         Bool_t rv = kTRUE ;
1321         TString tmp(AliQAv1::GetQARefStorage()) ;
1322         if ( tmp.IsNull() ) {
1323                 AliError("No storage defined, use AliQAv1::SetQARefStorage") ;
1324                 return kFALSE ;
1325         }
1326         if ( !(tmp.Contains(AliQAv1::GetLabLocalOCDB()) || tmp.Contains(AliQAv1::GetLabAliEnOCDB())) ) {
1327                 AliError(Form("%s is a wrong storage, use %s or %s", AliQAv1::GetQARefStorage(), AliQAv1::GetLabLocalOCDB().Data(), AliQAv1::GetLabAliEnOCDB().Data())) ;
1328                 return kFALSE ;
1329         }
1330         TString sdet(detectors) ;
1331         sdet.ToUpper() ;
1332         TFile * inputFile ;
1333         if ( sdet.Contains("ALL") ) {
1334                 rv = Merge(runNumber) ;
1335                 if ( ! rv )
1336                         return kFALSE ;
1337                 TString inputFileName(Form("Merged.%s.Data.%d.root", AliQAv1::GetQADataFileName(), runNumber)) ;
1338                 inputFile = TFile::Open(inputFileName.Data()) ;
1339                 rv = SaveIt2OCDB(runNumber, inputFile, year, es) ;
1340         } else {
1341                 for (Int_t index = 0; index < AliQAv1::kNDET; index++) {
1342                         if (sdet.Contains(AliQAv1::GetDetName(index))) {
1343                                 TString inputFileName(Form("%s.%s.%d.root", AliQAv1::GetDetName(index), AliQAv1::GetQADataFileName(), runNumber)) ;
1344                                 inputFile = TFile::Open(inputFileName.Data()) ;
1345                                 rv *= SaveIt2OCDB(runNumber, inputFile, year, es) ;
1346                         }
1347                 }
1348         }
1349         return rv ;
1350 }
1351
1352 //_____________________________________________________________________________
1353 Bool_t AliQAManager::SaveIt2OCDB(const Int_t runNumber, TFile * inputFile, const Char_t * year, AliRecoParam::EventSpecie_t es) const
1354 {
1355         // reads the TH1 from file and adds it to appropriate list before saving to OCDB
1356         Bool_t rv = kTRUE ;
1357         AliDebug(AliQAv1::GetQADebugLevel(), Form("Saving TH1s in %s to %s", inputFile->GetName(), AliQAv1::GetQARefStorage())) ;
1358         if ( ! IsDefaultStorageSet() ) {
1359                 TString tmp( AliQAv1::GetQARefStorage() ) ;
1360                 if ( tmp.Contains(AliQAv1::GetLabLocalOCDB()) )
1361                         Instance()->SetDefaultStorage(AliQAv1::GetQARefStorage()) ;
1362                 else {
1363                         TString tmp1(AliQAv1::GetQARefDefaultStorage()) ;
1364                         tmp1.Append(year) ;
1365                         tmp1.Append("?user=alidaq") ;
1366                         Instance()->SetDefaultStorage(tmp1.Data()) ;
1367                 }
1368         }
1369         Instance()->SetSpecificStorage("*", AliQAv1::GetQARefStorage()) ;
1370         if(GetRun() < 0)
1371                 Instance()->SetRun(runNumber);
1372
1373         AliCDBMetaData mdr ;
1374         mdr.SetResponsible("yves schutz");
1375
1376         for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++) {
1377                 TDirectory * detDir = inputFile->GetDirectory(AliQAv1::GetDetName(detIndex)) ;
1378                 if ( detDir ) {
1379                         AliDebug(AliQAv1::GetQADebugLevel(), Form("Entering %s", detDir->GetName())) ;
1380       AliQAv1::SetQARefDataDirName(es) ;
1381                         TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetDetName(detIndex), AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName())) ;
1382                         AliCDBId idr(detOCDBDir.Data(), runNumber, AliCDBRunRange::Infinity())  ;
1383                         TList * listDetQAD = new TList() ;
1384                         TString listName(Form("%s QA data Reference", AliQAv1::GetDetName(detIndex))) ;
1385                         mdr.SetComment(Form("%s QA stuff", AliQAv1::GetDetName(detIndex)));
1386                         listDetQAD->SetName(listName) ;
1387                         TList * taskList = detDir->GetListOfKeys() ;
1388                         TIter nextTask(taskList) ;
1389                         TKey * taskKey ;
1390                         while ( (taskKey = static_cast<TKey*>(nextTask())) ) {
1391                                 TDirectory * taskDir = detDir->GetDirectory(taskKey->GetName()) ;
1392         TDirectory * esDir   = taskDir->GetDirectory(AliRecoParam::GetEventSpecieName(es)) ;
1393                                 AliDebug(AliQAv1::GetQADebugLevel(), Form("Saving %s", esDir->GetName())) ;
1394                                 TObjArray * listTaskQAD = new TObjArray(100) ;
1395                                 listTaskQAD->SetName(Form("%s/%s", taskKey->GetName(), AliRecoParam::GetEventSpecieName(es))) ;
1396                                 listDetQAD->Add(listTaskQAD) ;
1397                                 TList * histList = esDir->GetListOfKeys() ;
1398                                 TIter nextHist(histList) ;
1399                                 TKey * histKey ;
1400                                 while ( (histKey = static_cast<TKey*>(nextHist())) ) {
1401                                         TObject * odata = esDir->Get(histKey->GetName()) ;
1402                                         if ( !odata ) {
1403                                                 AliError(Form("%s in %s/%s returns a NULL pointer !!", histKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
1404                                         } else {
1405             if ( AliQAv1::GetExpert() == histKey->GetName() ) {
1406               TDirectory * expertDir   = esDir->GetDirectory(histKey->GetName()) ;
1407               TList * expertHistList = expertDir->GetListOfKeys() ;
1408               TIter nextExpertHist(expertHistList) ;
1409               TKey * expertHistKey ;
1410               while ( (expertHistKey = static_cast<TKey*>(nextExpertHist())) ) {
1411                 TObject * expertOdata = expertDir->Get(expertHistKey->GetName()) ;
1412                 if ( !expertOdata ) {
1413                   AliError(Form("%s in %s/%s/Expert returns a NULL pointer !!", expertHistKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
1414                 } else {
1415                   AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", expertHistKey->GetName())) ;
1416                   if ( expertOdata->IsA()->InheritsFrom("TH1") ) {
1417                     AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", expertHistKey->GetName())) ;
1418                     TH1 * hExpertdata = static_cast<TH1*>(expertOdata) ;
1419                     listTaskQAD->Add(hExpertdata) ;
1420                   }
1421                 }
1422               }
1423             }
1424                                                 AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", histKey->GetName())) ;
1425                                                 if ( odata->IsA()->InheritsFrom("TH1") ) {
1426                                                         AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", histKey->GetName())) ;
1427                                                         TH1 * hdata = static_cast<TH1*>(odata) ;
1428                                                         listTaskQAD->Add(hdata) ;
1429                                                 }
1430                                         }
1431                                 }
1432                         }
1433                         Instance()->Put(listDetQAD, idr, &mdr) ;
1434                 }
1435         }
1436         return rv ;
1437 }
1438
1439 //_____________________________________________________________________________
1440
1441 void AliQAManager::SetCheckerExternParam(AliQAv1::DETECTORINDEX_t detIndex, TList * parameterList)
1442 {
1443   // set the external parameters list for the detector checkers
1444   AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(detIndex) ;
1445   qac->SetExternParamlist(parameterList) ;
1446   qac->PrintExternParam() ;
1447 }
1448
1449 //_____________________________________________________________________________
1450 void AliQAManager::SetEventSpecie(AliRecoParam::EventSpecie_t es)
1451 {
1452   // set the current event specie and inform AliQAv1 that this event specie has been encountered
1453   fEventSpecie = es ;
1454   AliQAv1::Instance()->SetEventSpecie(es) ;
1455 }
1456
1457 //_____________________________________________________________________________
1458 void AliQAManager::SetRecoParam(const Int_t det, const AliDetectorRecoParam *par)
1459 {
1460   // Set custom reconstruction parameters for a given detector
1461   // Single set of parameters for all the events
1462   GetQADataMaker(det)->SetRecoParam(par) ;
1463 }
1464
1465 //_____________________________________________________________________________
1466 void AliQAManager::SetWriteExpert()
1467 {
1468   // enable the writing of QA expert data
1469   for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1470         if (IsSelected(AliQAv1::GetDetName(iDet)))
1471       fQAWriteExpert[iDet] = kTRUE ;
1472   }
1473 }
1474
1475 //_____________________________________________________________________________
1476 void AliQAManager::Destroy() {
1477   // delete AliQAManager instance and
1478   // all associated objects
1479
1480   if (fgQAInstance) {
1481     delete fgQAInstance ;
1482     fgQAInstance = NULL ;
1483   }
1484 }
1485
1486 //_____________________________________________________________________________
1487 void AliQAManager::ShowQA() {
1488   // Show the result of the QA checking
1489   // for all detectors
1490         for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++)
1491     AliQAv1::Instance(AliQAv1::GetDetIndex(AliQAv1::GetDetName(detIndex)))->Show() ;
1492 }