STEER/STEER/AliQAManager.cxx

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