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(AliQA::kRAWS, rawROOTFileName);                                 //
  23 //   qas.Run(AliQA::kHITS);                                                  //
  24 //   qas.Run(AliQA::kSDIGITS);                                               //
  25 //   qas.Run(AliQA::kDIGITS);                                                //
  26 //   qas.Run(AliQA::kRECPOINTS);                                             //
  27 //   qas.Run(AliQA::kESDS);                                                  //
  28 //                                                                           //
  29 ///////////////////////////////////////////////////////////////////////////////
  30
  31 #include <TAlienCollection.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
  43 #include "AliCDBManager.h"
  44 #include "AliCDBEntry.h"
  45 #include "AliCDBId.h"
  46 #include "AliCDBMetaData.h"
  47 #include "AliCodeTimer.h"
  48 #include "AliCorrQADataMakerRec.h"
  49 #include "AliDetectorRecoParam.h"
  50 #include "AliESDEvent.h"
  51 #include "AliGeomManager.h"
  52 #include "AliGlobalQADataMaker.h"
  53 #include "AliHeader.h"
  54 #include "AliLog.h"
  55 #include "AliModule.h"
  56 #include "AliQA.h"
  57 #include "AliQADataMakerRec.h"
  58 #include "AliQADataMakerSim.h"
  59 #include "AliQAManager.h"
  60 #include "AliRawReaderDate.h"
  61 #include "AliRawReaderFile.h"
  62 #include "AliRawReaderRoot.h"
  63 #include "AliRun.h"
  64 #include "AliRunLoader.h"
  65 #include "AliRunTag.h"
  66
  67 ClassImp(AliQAManager)
  68 AliQAManager* AliQAManager::fgQAInstance = 0x0;
  69
  70 //_____________________________________________________________________________
  71 AliQAManager::AliQAManager() :
  72   AliCDBManager(),
  73   fCurrentEvent(0),
  74   fCycleSame(kFALSE),
  75   fDetectors("ALL"),
  76   fDetectorsW("ALL"),
  77   fESD(NULL),
  78   fESDTree(NULL),
  79   fGAliceFileName(""),
  80   fFirstEvent(0),
  81   fMaxEvents(0),
  82   fMode(""),
  83   fNumberOfEvents(999999),
  84   fRecoParam(),
  85   fRunNumber(0),
  86   fRawReader(NULL),
  87   fRawReaderDelete(kTRUE),
  88   fRunLoader(NULL),
  89   fTasks(""),
  90   fEventSpecie(AliRecoParam::kDefault)
  91 {
  92         // default ctor
  93         fMaxEvents = fNumberOfEvents ;
  94         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
  95                 if (IsSelected(AliQA::GetDetName(iDet))) {
  96                         fLoader[iDet]      = NULL ;
  97                         fQADataMaker[iDet] = NULL ;
  98                         fQACycles[iDet]    = 999999 ;
  99       fQAWriteExpert[iDet] = kTRUE ;
 100                 }
 101         }
 102 }
 103
 104 //_____________________________________________________________________________
 105 AliQAManager::AliQAManager(const Char_t * mode, const Char_t* gAliceFilename) :
 106   AliCDBManager(),
 107   fCurrentEvent(0),
 108         fCycleSame(kFALSE),
 109         fDetectors("ALL"),
 110         fDetectorsW("ALL"),
 111         fESD(NULL),
 112         fESDTree(NULL),
 113         fGAliceFileName(gAliceFilename),
 114         fFirstEvent(0),
 115         fMaxEvents(0),
 116   fMode(mode),
 117         fNumberOfEvents(999999),
 118   fRecoParam(),
 119         fRunNumber(0),
 120         fRawReader(NULL),
 121         fRawReaderDelete(kTRUE),
 122         fRunLoader(NULL),
 123   fTasks(""),
 124   fEventSpecie(AliRecoParam::kDefault)
 125 {
 126         // default ctor
 127         fMaxEvents = fNumberOfEvents ;
 128         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 129                 if (IsSelected(AliQA::GetDetName(iDet))) {
 130                         fLoader[iDet]      = NULL ;
 131                         fQADataMaker[iDet] = NULL ;
 132                         fQACycles[iDet]    = 999999 ;
 133       fQAWriteExpert[iDet] = kTRUE ;
 134     }
 135   }
 136 }
 137
 138 //_____________________________________________________________________________
 139 AliQAManager::AliQAManager(const AliQAManager & qas) :
 140   AliCDBManager(),
 141         fCurrentEvent(qas.fCurrentEvent),
 142         fCycleSame(kFALSE),
 143         fDetectors(qas.fDetectors),
 144         fDetectorsW(qas.fDetectorsW),
 145         fESD(NULL),
 146         fESDTree(NULL),
 147         fGAliceFileName(qas.fGAliceFileName),
 148         fFirstEvent(qas.fFirstEvent),
 149         fMaxEvents(qas.fMaxEvents),
 150         fMode(qas.fMode),
 151         fNumberOfEvents(qas.fNumberOfEvents),
 152         fRecoParam(),
 153         fRunNumber(qas.fRunNumber),
 154         fRawReader(NULL),
 155         fRawReaderDelete(kTRUE),
 156         fRunLoader(NULL),
 157   fTasks(qas.fTasks),
 158   fEventSpecie(qas.fEventSpecie)
 159 {
 160         // cpy ctor
 161         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 162                 fLoader[iDet]         = qas.fLoader[iDet] ;
 163                 fQADataMaker[iDet]    = qas.fQADataMaker[iDet] ;
 164                 fQACycles[iDet]       = qas.fQACycles[iDet] ;
 165     fQAWriteExpert[iDet] = qas.fQAWriteExpert[iDet] ;
 166   }
 167 }
 168
 169 //_____________________________________________________________________________
 170 AliQAManager & AliQAManager::operator = (const AliQAManager & qas)
 171 {
 172         // assignment operator
 173   this->~AliQAManager() ;
 174   new(this) AliQAManager(qas) ;
 175   return *this ;
 176 }
 177
 178 //_____________________________________________________________________________
 179 AliQAManager::~AliQAManager()
 180 {
 181         // dtor
 182         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 183                 if (IsSelected(AliQA::GetDetName(iDet))) {
 184                   fLoader[iDet] = NULL;
 185                   if (fQADataMaker[iDet]) {
 186                           (fQADataMaker[iDet])->Finish() ;
 187                                 delete fQADataMaker[iDet] ;
 188                   }
 189                 }
 190         }
 191         if (fRawReaderDelete) {
 192                 fRunLoader = NULL ;
 193                 delete fRawReader ;
 194                 fRawReader = NULL ;
 195         }
 196 }
 197
 198 //_____________________________________________________________________________
 199 Bool_t AliQAManager::DoIt(const AliQA::TASKINDEX_t taskIndex)
 200 {
 201         // Runs all the QA data Maker for every detector
 202
 203         Bool_t rv = kFALSE ;
 204     // Fill QA data in event loop
 205         for (UInt_t iEvent = fFirstEvent ; iEvent < (UInt_t)fMaxEvents ; iEvent++) {
 206                 fCurrentEvent++ ;
 207                 // Get the event
 208                 if ( iEvent%10 == 0  )
 209                         AliInfo(Form("processing event %d", iEvent));
 210                 if ( taskIndex == AliQA::kRAWS ) {
 211                         if ( !fRawReader->NextEvent() )
 212                                 break ;
 213                 } else if ( taskIndex == AliQA::kESDS ) {
 214                         if ( fESDTree->GetEntry(iEvent) == 0 )
 215                                 break ;
 216                 } else {
 217                         if ( fRunLoader->GetEvent(iEvent) != 0 )
 218                                 break ;
 219                 }
 220                 // loop  over active loaders
 221                 for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 222                         if (IsSelected(AliQA::GetDetName(iDet))) {
 223                                 AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 224                                 if (!qadm) continue; // This detector doesn't have any QA (for example, HLT)
 225                                 if ( qadm->IsCycleDone() ) {
 226           qadm->EndOfCycle(taskIndex) ;
 227                                 }
 228                                 TTree * data = NULL ;
 229                                 AliLoader* loader = GetLoader(qadm->GetUniqueID());
 230                                 switch (taskIndex) {
 231                                         case AliQA::kNULLTASKINDEX :
 232                                                 break ;
 233                                         case AliQA::kRAWS :
 234                                                 qadm->Exec(taskIndex, fRawReader) ;
 235                                                 break ;
 236                                         case AliQA::kHITS :
 237             if( loader ) {
 238               loader->LoadHits() ;
 239               data = loader->TreeH() ;
 240               if ( ! data ) {
 241                 AliWarning(Form(" Hit Tree not found for  %s", AliQA::GetDetName(iDet))) ;
 242                 break ;
 243               }
 244             }
 245             qadm->Exec(taskIndex, data) ;
 246                                                 break ;
 247                                                 case AliQA::kSDIGITS :
 248             if( loader ) {
 249               loader->LoadSDigits() ;
 250               data = loader->TreeS() ;
 251               if ( ! data ) {
 252                 AliWarning(Form(" SDigit Tree not found for  %s", AliQA::GetDetName(iDet))) ;
 253                 break ;
 254               }
 255             }
 256             qadm->Exec(taskIndex, data) ;
 257                                                 break;
 258                                                 case AliQA::kDIGITS :
 259             if( loader ) {
 260               loader->LoadDigits() ;
 261               data = loader->TreeD() ;
 262               if ( ! data ) {
 263                 AliWarning(Form(" Digit Tree not found for  %s", AliQA::GetDetName(iDet))) ;
 264                 break ;
 265               }
 266             }
 267             qadm->Exec(taskIndex, data) ;
 268                                                 break;
 269                                                 case AliQA::kRECPOINTS :
 270             if( loader ) {
 271               loader->LoadRecPoints() ;
 272               data = loader->TreeR() ;
 273               if (!data) {
 274                 AliWarning(Form("RecPoints not found for %s", AliQA::GetDetName(iDet))) ;
 275                 break ;
 276               }
 277             }
 278             qadm->Exec(taskIndex, data) ;
 279             break;
 280                                                 case AliQA::kTRACKSEGMENTS :
 281                                                 break;
 282                                                 case AliQA::kRECPARTICLES :
 283                                                 break;
 284                                                 case AliQA::kESDS :
 285                                                 qadm->Exec(taskIndex, fESD) ;
 286                                                 break;
 287                                                 case AliQA::kNTASKINDEX :
 288                                                 break;
 289                                 } //task switch
 290                         }
 291                 } // detector loop
 292     Increment() ;
 293         } // event loop
 294         // Save QA data for all detectors
 295         rv = Finish(taskIndex) ;
 296
 297         if ( taskIndex == AliQA::kRAWS )
 298                 fRawReader->RewindEvents() ;
 299
 300         return rv ;
 301 }
 302
 303 //_____________________________________________________________________________
 304 Bool_t AliQAManager::Finish(const AliQA::TASKINDEX_t taskIndex)
 305 {
 306         // write output to file for all detectors
 307         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 308                 if (IsSelected(AliQA::GetDetName(iDet))) {
 309                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 310                         if (qadm)
 311         qadm->EndOfCycle(taskIndex) ;
 312                 }
 313         }
 314         return kTRUE ;
 315 }
 316
 317 //_____________________________________________________________________________
 318 TObjArray * AliQAManager::GetFromOCDB(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, const char * year) const
 319 {
 320         // Retrieve the list of QA data for a given detector and a given task
 321         TObjArray * rv = NULL ;
 322         if ( !strlen(AliQA::GetQARefStorage()) ) {
 323                 AliError("No storage defined, use AliQA::SetQARefStorage") ;
 324                 return NULL ;
 325         }
 326         if ( ! IsDefaultStorageSet() ) {
 327                 TString tmp(AliQA::GetQARefDefaultStorage()) ;
 328                 tmp.Append(year) ;
 329                 tmp.Append("/") ;
 330                 Instance()->SetDefaultStorage(tmp.Data()) ;
 331                 Instance()->SetSpecificStorage(Form("%s/*", AliQA::GetQAName()), AliQA::GetQARefStorage()) ;
 332         }
 333         TString detOCDBDir(Form("%s/%s/%s", AliQA::GetQAName(), AliQA::GetDetName((Int_t)det), AliQA::GetRefOCDBDirName())) ;
 334         AliInfo(Form("Retrieving reference data from %s/%s for %s", AliQA::GetQARefStorage(), detOCDBDir.Data(), AliQA::GetTaskName(task).Data())) ;
 335         AliCDBEntry* entry = QAManager()->Get(detOCDBDir.Data(), 0) ; //FIXME 0 --> Run Number
 336         TList * listDetQAD = dynamic_cast<TList *>(entry->GetObject()) ;
 337         if ( listDetQAD )
 338                 rv = dynamic_cast<TObjArray *>(listDetQAD->FindObject(AliQA::GetTaskName(task))) ;
 339         return rv ;
 340 }
 341
 342 //_____________________________________________________________________________
 343 AliLoader * AliQAManager::GetLoader(Int_t iDet)
 344 {
 345         // get the loader for a detector
 346
 347         if ( !fRunLoader || iDet == AliQA::kCORR)
 348                 return NULL ;
 349
 350         TString detName = AliQA::GetDetName(iDet) ;
 351     fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
 352         if (fLoader[iDet])
 353                 return fLoader[iDet] ;
 354
 355         // load the QA data maker object
 356         TPluginManager* pluginManager = gROOT->GetPluginManager() ;
 357         TString loaderName = "Ali" + detName + "Loader" ;
 358
 359         AliLoader * loader = NULL ;
 360         // first check if a plugin is defined for the quality assurance data maker
 361         TPluginHandler* pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
 362         // if not, add a plugin for it
 363         if (!pluginHandler) {
 364                 AliDebug(1, Form("defining plugin for %s", loaderName.Data())) ;
 365                 TString libs = gSystem->GetLibraries() ;
 366                 if (libs.Contains("lib" + detName + "base.so") || (gSystem->Load("lib" + detName + "base.so") >= 0)) {
 367                         pluginManager->AddHandler("AliQADataMaker", detName, loaderName, detName + "loader", loaderName + "()") ;
 368                 } else {
 369                         pluginManager->AddHandler("AliLoader", detName, loaderName, detName, loaderName + "()") ;
 370                 }
 371                 pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
 372         }
 373         if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
 374                 loader = (AliLoader *) pluginHandler->ExecPlugin(0) ;
 375         }
 376         if (loader)
 377                 fLoader[iDet] = loader ;
 378         return loader ;
 379 }
 380
 381 //_____________________________________________________________________________
 382 AliQA * AliQAManager::GetQA(UInt_t run, UInt_t evt)
 383 {
 384 // retrieves the QA object stored in a file named "Run{run}.Event{evt}_1.ESD.tag.root"
 385   char * fileName = Form("Run%d.Event%d_1.ESD.tag.root", run, evt) ;
 386   TFile * tagFile = TFile::Open(fileName) ;
 387   if ( !tagFile ) {
 388     AliError(Form("File %s not found", fileName)) ;
 389     return NULL ;
 390   }
 391   TTree * tagTree = dynamic_cast<TTree *>(tagFile->Get("T")) ;
 392   if ( !tagTree ) {
 393     AliError(Form("Tree T not found in %s", fileName)) ;
 394     tagFile->Close() ;
 395     return NULL ;
 396   }
 397   AliRunTag * tag = new AliRunTag ;
 398   tagTree->SetBranchAddress("AliTAG", &tag) ;
 399   tagTree->GetEntry(evt) ;
 400   AliQA * qa = AliQA::Instance(tag->GetQALength(), tag->GetQA(), tag->GetESLength(), tag->GetEventSpecies()) ;
 401   tagFile->Close() ;
 402   return qa ;
 403 }
 404
 405 //_____________________________________________________________________________
 406 AliQADataMaker * AliQAManager::GetQADataMaker(const Int_t iDet)
 407 {
 408         // get the quality assurance data maker for a detector
 409
 410         if (fQADataMaker[iDet]) {
 411     fQADataMaker[iDet]->SetEventSpecie(fEventSpecie) ;
 412                 return fQADataMaker[iDet] ;
 413   }
 414
 415         AliQADataMaker * qadm = NULL ;
 416
 417         if (iDet == AliQA::kGLOBAL) { //Global QA
 418                 qadm = new AliGlobalQADataMaker();
 419                 qadm->SetName(AliQA::GetDetName(iDet));
 420                 qadm->SetUniqueID(iDet);
 421                 fQADataMaker[iDet] = qadm;
 422     qadm->SetEventSpecie(fEventSpecie) ;
 423                 return qadm;
 424         }
 425
 426         if (iDet == AliQA::kCORR) { //the data maker for correlations among detectors
 427     qadm = new AliCorrQADataMakerRec(fQADataMaker) ;
 428                 qadm->SetName(AliQA::GetDetName(iDet));
 429                 qadm->SetUniqueID(iDet);
 430                 fQADataMaker[iDet] = qadm;
 431     qadm->SetEventSpecie(fEventSpecie) ;
 432                 return qadm;
 433   }
 434
 435         // load the QA data maker object
 436         TPluginManager* pluginManager = gROOT->GetPluginManager() ;
 437         TString detName = AliQA::GetDetName(iDet) ;
 438         TString tmp(fMode) ;
 439         if (tmp.Contains("sim"))
 440                 tmp.ReplaceAll("s", "S") ;
 441         else if (tmp.Contains("rec"))
 442                 tmp.ReplaceAll("r", "R") ;
 443
 444         TString qadmName = "Ali" + detName + "QADataMaker" + tmp ;
 445
 446         // first check if a plugin is defined for the quality assurance data maker
 447         TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
 448         // if not, add a plugin for it
 449         if (!pluginHandler) {
 450                 AliDebug(1, Form("defining plugin for %s", qadmName.Data())) ;
 451                 TString libs = gSystem->GetLibraries() ;
 452                 if (libs.Contains("lib" + detName + fMode + ".so") || (gSystem->Load("lib" + detName + fMode + ".so") >= 0)) {
 453                         pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName + "qadm", qadmName + "()") ;
 454                 } else {
 455                         pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName, qadmName + "()") ;
 456                 }
 457                 pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
 458         }
 459         if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
 460                 qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0) ;
 461         }
 462         if (qadm) {
 463                 qadm->SetName(AliQA::GetDetName(iDet));
 464                 qadm->SetUniqueID(iDet);
 465                 fQADataMaker[iDet] = qadm ;
 466     qadm->SetEventSpecie(fEventSpecie) ;
 467         }
 468
 469   return qadm ;
 470 }
 471
 472 //_____________________________________________________________________________
 473 void  AliQAManager::EndOfCycle(TObjArray * detArray)
 474 {
 475         // End of cycle QADataMakers
 476
 477         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 478                 if (IsSelected(AliQA::GetDetName(iDet))) {
 479                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 480                         if (!qadm)
 481                                 continue ;
 482                         // skip non active detectors
 483                         if (detArray) {
 484                                 AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQA::GetDetName(iDet))) ;
 485                                 if (!det || !det->IsActive())
 486                                         continue ;
 487                         }
 488                         for (UInt_t taskIndex = 0; taskIndex < AliQA::kNTASKINDEX; taskIndex++) {
 489                                 if ( fTasks.Contains(Form("%d", taskIndex)) )
 490                                         qadm->EndOfCycle(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex))) ;
 491                         }
 492                         qadm->Finish();
 493                 }
 494         }
 495 }
 496
 497 //_____________________________________________________________________________
 498 void  AliQAManager::EndOfCycle(TString detectors)
 499 {
 500         // End of cycle QADataMakers
 501
 502         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 503                 if (IsSelected(AliQA::GetDetName(iDet))) {
 504                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 505                         if (!qadm)
 506                                 continue ;
 507                         // skip non active detectors
 508       if (!detectors.Contains(AliQA::GetDetName(iDet)))
 509         continue ;
 510                 for (UInt_t taskIndex = 0; taskIndex < AliQA::kNTASKINDEX; taskIndex++) {
 511                                 if ( fTasks.Contains(Form("%d", taskIndex)) )
 512                                         qadm->EndOfCycle(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex))) ;
 513                         }
 514                         qadm->Finish();
 515                 }
 516         }
 517 }
 518
 519 //_____________________________________________________________________________
 520 void AliQAManager::Increment()
 521 {
 522   // Increments the cycle counter for all QA Data Makers
 523         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 524                 if (IsSelected(AliQA::GetDetName(iDet))) {
 525                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 526                         if (qadm)
 527         qadm->Increment() ;
 528     }
 529   }
 530 }
 531
 532 //_____________________________________________________________________________
 533 Bool_t AliQAManager::InitQA(const AliQA::TASKINDEX_t taskIndex, const  char * input )
 534 {
 535         // Initialize the event source and QA data makers
 536
 537         fTasks += Form("%d", taskIndex) ;
 538
 539         if (taskIndex == AliQA::kRAWS) {
 540                 if (!fRawReader) {
 541                         fRawReader = AliRawReader::Create(input);
 542                 }
 543                 if ( ! fRawReader )
 544                         return kFALSE ;
 545                 fRawReaderDelete = kTRUE ;
 546                 fRawReader->NextEvent() ;
 547                 fRunNumber = fRawReader->GetRunNumber() ;
 548                 SetRun(fRunNumber) ;
 549                 fRawReader->RewindEvents();
 550                 fNumberOfEvents = 999999 ;
 551                 if ( fMaxEvents < 0 )
 552                         fMaxEvents = fNumberOfEvents ;
 553                 } else if (taskIndex == AliQA::kESDS) {
 554                         fTasks = AliQA::GetTaskName(AliQA::kESDS) ;
 555       if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
 556         TFile * esdFile = TFile::Open("AliESDs.root") ;
 557         fESDTree = dynamic_cast<TTree *> (esdFile->Get("esdTree")) ;
 558         if ( !fESDTree ) {
 559           AliError("esdTree not found") ;
 560           return kFALSE ;
 561         } else {
 562           fESD     = new AliESDEvent() ;
 563           fESD->ReadFromTree(fESDTree) ;
 564           fESDTree->GetEntry(0) ;
 565           fRunNumber = fESD->GetRunNumber() ;
 566           fNumberOfEvents = fESDTree->GetEntries() ;
 567           if ( fMaxEvents < 0 )
 568             fMaxEvents = fNumberOfEvents ;
 569         }
 570       } else {
 571         AliError("AliESDs.root not found") ;
 572         return kFALSE ;
 573       }
 574     } else {
 575       if ( !InitRunLoader() ) {
 576         AliWarning("No Run Loader not found") ;
 577       } else {
 578         fNumberOfEvents = fRunLoader->GetNumberOfEvents() ;
 579         if ( fMaxEvents < 0 )
 580           fMaxEvents = fNumberOfEvents ;
 581       }
 582     }
 583
 584   // Get Detectors
 585   TObjArray* detArray = NULL ;
 586         if (fRunLoader) // check if RunLoader exists
 587                 if ( fRunLoader->GetAliRun() ) { // check if AliRun exists in gAlice.root
 588                         detArray = fRunLoader->GetAliRun()->Detectors() ;
 589                         fRunNumber = fRunLoader->GetHeader()->GetRun() ;
 590                 }
 591
 592         // Initialize all QA data makers for all detectors
 593         fRunNumber = AliCDBManager::Instance()->GetRun() ;
 594         if ( !  AliGeomManager::GetGeometry() )
 595                 AliGeomManager::LoadGeometry() ;
 596
 597         InitQADataMaker(fRunNumber, detArray) ; //, fCycleSame, kTRUE, detArray) ;
 598         return kTRUE ;
 599 }
 600
 601 //_____________________________________________________________________________
 602 void  AliQAManager::InitQADataMaker(UInt_t run, TObjArray * detArray)
 603 {
 604         // Initializes The QADataMaker for all active detectors and for all active tasks
 605         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 606                 if (IsSelected(AliQA::GetDetName(iDet))) {
 607                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
 608                         if (!qadm) {
 609                                 AliError(Form("AliQADataMaker not found for %s", AliQA::GetDetName(iDet))) ;
 610                                 fDetectorsW.ReplaceAll(AliQA::GetDetName(iDet), "") ;
 611                         } else {
 612         if (fQAWriteExpert[iDet])
 613           qadm->SetWriteExpert() ;
 614                                 AliDebug(1, Form("Data Maker found for %s", qadm->GetName())) ;
 615                                 // skip non active detectors
 616                                 if (detArray) {
 617                                         AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQA::GetDetName(iDet))) ;
 618                                         if (!det || !det->IsActive())
 619                                                 continue ;
 620                                 }
 621                                 if (fQAWriteExpert[iDet]) qadm->SetWriteExpert() ;
 622               // Set default reco params
 623         Bool_t sameCycle = kFALSE ;
 624                                 for (UInt_t taskIndex = 0; taskIndex < AliQA::kNTASKINDEX; taskIndex++) {
 625                                         if ( fTasks.Contains(Form("%d", taskIndex)) ) {
 626                                                 qadm->Init(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex)), GetQACycles(qadm->GetUniqueID())) ;
 627             qadm->StartOfCycle(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex)), run,  sameCycle) ;
 628             sameCycle = kTRUE ;
 629                                         }
 630                                 }
 631                         }
 632                 }
 633         }
 634 }
 635
 636
 637 //_____________________________________________________________________________
 638 Bool_t AliQAManager::InitRunLoader()
 639 {
 640         // get or create the run loader
 641         if (fRunLoader) {
 642                 fCycleSame = kTRUE ;
 643         } else {
 644                 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
 645                         // load all base libraries to get the loader classes
 646                         TString libs = gSystem->GetLibraries() ;
 647                         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 648                                 if (!IsSelected(AliQA::GetDetName(iDet)))
 649                                         continue ;
 650                                 TString detName = AliQA::GetDetName(iDet) ;
 651                                 if (detName == "HLT")
 652                                         continue;
 653                                 if (libs.Contains("lib" + detName + "base.so"))
 654                                         continue;
 655                                 gSystem->Load("lib" + detName + "base.so");
 656                         }
 657                         fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
 658                         if (!fRunLoader) {
 659                                 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
 660                                 return kFALSE;
 661                         }
 662                         fRunLoader->CdGAFile();
 663                         if (fRunLoader->LoadgAlice() == 0) {
 664                                 gAlice = fRunLoader->GetAliRun();
 665                         }
 666
 667                         if (!gAlice) {
 668                                 AliError(Form("no gAlice object found in file %s", fGAliceFileName.Data()));
 669                                 return kFALSE;
 670                         }
 671
 672                 } else {               // galice.root does not exist
 673                         AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
 674                         return kFALSE;
 675                 }
 676         }
 677
 678         if (!fRunNumber) {
 679                 fRunLoader->LoadHeader();
 680                 fRunNumber = fRunLoader->GetHeader()->GetRun() ;
 681         }
 682         return kTRUE;
 683 }
 684
 685 //_____________________________________________________________________________
 686 Bool_t AliQAManager::IsSelected(const char * det)
 687 {
 688   // check whether detName is contained in detectors
 689         // if yes, it is removed from detectors
 690
 691         Bool_t rv = kFALSE;
 692         const TString detName(det) ;
 693   // always activates Correlation
 694   if ( detName.Contains(AliQA::GetDetName(AliQA::kCORR))) {
 695     rv = kTRUE ;
 696   } else {
 697     // check if all detectors are selected
 698     if (fDetectors.Contains("ALL")) {
 699       fDetectors = "ALL";
 700       rv = kTRUE;
 701     } else if ((fDetectors.CompareTo(detName) == 0) ||
 702                fDetectors.BeginsWith(detName+" ") ||
 703                fDetectors.EndsWith(" "+detName) ||
 704                fDetectors.Contains(" "+detName+" ")) {
 705       rv = kTRUE;
 706     }
 707   }
 708         return rv ;
 709 }
 710
 711 //_____________________________________________________________________________
 712 Bool_t AliQAManager::Merge(const Int_t runNumber) const
 713 {
 714         // Merge data from all the cycles from all detectors in one single file per run
 715         // Merge the QA results from all the data chunks in one run
 716  Bool_t rv = MergeData(runNumber) ;
 717  rv *= MergeResults(runNumber) ;
 718  return rv ;
 719 }
 720
 721 //______________________________________________________________________
 722 Bool_t AliQAManager::MergeXML(const char * collectionFile, const char * subFile, const char * outFile)
 723 {
 724   // merges files listed in a xml collection
 725   // usage Merge(collection, outputFile))
 726   //              collection: is a xml collection
 727
 728   Bool_t rv = kFALSE ;
 729
 730   if ( strstr(collectionFile, ".xml") == 0 ) {
 731     AliError("Input collection file must be an \".xml\" file\n") ;
 732     return kFALSE ;
 733   }
 734
 735  if ( !gGrid )
 736    TGrid::Connect("alien://");
 737  if ( !gGrid )
 738    return kFALSE ;
 739
 740   // Open the file collection
 741   printf("*** Create Collection       ***\n");
 742   printf("***  Wk-Dir = |%s|             \n",gSystem->WorkingDirectory());
 743   printf("***  Coll   = |%s|             \n",collectionFile);
 744
 745   TGridCollection * collection = TAlienCollection::Open(collectionFile);
 746   TGridResult* result = collection->GetGridResult("", 0, 0);
 747
 748   Int_t index = 0  ;
 749   const char * turl ;
 750   TFileMerger merger ;
 751   if (!outFile) {
 752     TString tempo(collectionFile) ;
 753     if ( subFile)
 754       tempo.ReplaceAll(".xml", subFile) ;
 755     else
 756       tempo.ReplaceAll(".xml", "_Merged.root") ;
 757     outFile = tempo.Data() ;
 758   }
 759   merger.OutputFile(outFile) ;
 760
 761   while ( (turl = result->GetKey(index, "turl")) ) {
 762     char * file ;
 763     if ( subFile )
 764       file = Form("%s#%s", turl, subFile) ;
 765     else
 766       file = Form("%s", turl) ;
 767
 768     AliInfo(Form("%s\n", file)) ;
 769     merger.AddFile(file) ;
 770     index++ ;
 771   }
 772
 773   if (index)
 774     merger.Merge() ;
 775
 776   AliInfo(Form("Files merged into %s\n", outFile)) ;
 777
 778   rv = kFALSE;
 779   return rv ;
 780 }
 781
 782 //_____________________________________________________________________________
 783 Bool_t AliQAManager::MergeData(const Int_t runNumber) const
 784 {
 785         // Merge all the cycles from all detectors in one single file per run
 786         TString cmd ;
 787         if (runNumber != -1)
 788                 cmd = Form(".! ls *%s*.%d.root > tempo.txt", AliQA::GetQADataFileName(), runNumber) ;
 789         else
 790                 cmd = Form(".! ls *%s*.*.root > tempo.txt", AliQA::GetQADataFileName()) ;
 791         gROOT->ProcessLine(cmd.Data()) ;
 792         ifstream in("tempo.txt") ;
 793         const Int_t runMax = 10 ;
 794         TString file[AliQA::kNDET*runMax] ;
 795
 796         Int_t index = 0 ;
 797         while ( 1 ) {
 798                 in >> file[index] ;
 799                 if ( !in.good() )
 800                         break ;
 801                 AliInfo(Form("index = %d file = %s", index, (file[index]).Data())) ;
 802                 index++ ;
 803         }
 804
 805         if ( index == 0 ) {
 806                 AliError(Form("run number %d not found", runNumber)) ;
 807                 return kFALSE ;
 808         }
 809
 810   TFileMerger merger ;
 811   TString outFileName ;
 812   if (runNumber != -1)
 813     outFileName = Form("Merged.%s.Data.%d.root",AliQA::GetQADataFileName(),runNumber);
 814   else
 815     outFileName = Form("Merged.%s.Data.root",AliQA::GetQADataFileName());
 816   merger.OutputFile(outFileName.Data()) ;
 817   for (Int_t ifile = 0 ; ifile < index-1 ; ifile++) {
 818     TString pattern(Form("%s.%d.", AliQA::GetQADataFileName(), runNumber));
 819     TString tmp(file[ifile]) ;
 820     if (tmp.Contains(pattern)) {
 821       merger.AddFile(tmp) ;
 822     }
 823         }
 824   merger.Merge() ;
 825         return kTRUE ;
 826 }
 827
 828 //_____________________________________________________________________________
 829 Bool_t AliQAManager::MergeResults(const Int_t runNumber) const
 830 {
 831         // Merge the QA result from all the data chunks in a run
 832         TString cmd ;
 833         cmd = Form(".! ls %s*.root > tempo.txt", AliQA::GetQADataFileName()) ;
 834         gROOT->ProcessLine(cmd.Data()) ;
 835         ifstream in("tempo.txt") ;
 836         const Int_t chunkMax = 100 ;
 837         TString fileList[chunkMax] ;
 838
 839         Int_t index = 0 ;
 840         while ( 1 ) {
 841                 TString file ;
 842                 in >> fileList[index] ;
 843                 if ( !in.good() )
 844                         break ;
 845                 AliInfo(Form("index = %d file = %s", index, (fileList[index].Data()))) ;
 846                 index++ ;
 847         }
 848
 849         if ( index == 0 ) {
 850                 AliError("No QA Result File found") ;
 851                 return kFALSE ;
 852         }
 853
 854         TFileMerger merger ;
 855   TString outFileName ;
 856   if (runNumber != -1)
 857     outFileName = Form("Merged.%s.Result.%d.root",AliQA::GetQADataFileName(),runNumber);
 858   else
 859     outFileName = Form("Merged.%s.Result.root",AliQA::GetQADataFileName());
 860         merger.OutputFile(outFileName.Data()) ;
 861         for (Int_t ifile = 0 ; ifile < index ; ifile++) {
 862                 TString file = fileList[ifile] ;
 863                 merger.AddFile(file) ;
 864         }
 865         merger.Merge() ;
 866
 867         return kTRUE ;
 868 }
 869
 870 //_____________________________________________________________________________
 871 void AliQAManager::Reset(const Bool_t sameCycle)
 872 {
 873         // Reset the default data members
 874
 875         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 876                 if (IsSelected(AliQA::GetDetName(iDet))) {
 877                         AliQADataMaker * qadm = GetQADataMaker(iDet);
 878                         qadm->Reset();
 879                 }
 880         }
 881         if (fRawReaderDelete) {
 882                 delete fRawReader ;
 883                 fRawReader      = NULL ;
 884         }
 885
 886         fCycleSame      = sameCycle ;
 887         fESD            = NULL ;
 888         fESDTree        = NULL ;
 889         //fFirst          = kTRUE ;
 890         fNumberOfEvents = 999999 ;
 891 }
 892
 893 //_____________________________________________________________________________
 894 AliQAManager * AliQAManager::QAManager(const Char_t * mode, TMap *entryCache, Int_t run)
 895 {
 896   // returns AliQAManager instance (singleton)
 897
 898         if (!fgQAInstance) {
 899     fgQAInstance = new AliQAManager(mode) ;
 900     if (!entryCache)
 901                   fgQAInstance->Init();
 902                 else
 903                   fgQAInstance->InitFromCache(entryCache,run);
 904   }
 905         return fgQAInstance;
 906 }
 907
 908 //_____________________________________________________________________________
 909 TString AliQAManager::Run(const char * detectors, AliRawReader * rawReader, const Bool_t sameCycle)
 910 {
 911         //Runs all the QA data Maker for Raws only
 912
 913         fCycleSame       = sameCycle ;
 914         fRawReader       = rawReader ;
 915         fDetectors       = detectors ;
 916         fDetectorsW      = detectors ;
 917
 918         AliCDBManager* man = AliCDBManager::Instance() ;
 919
 920         if ( man->GetRun() == -1 ) {// check if run number not set previously and set it from raw data
 921                 rawReader->NextEvent() ;
 922                 man->SetRun(fRawReader->GetRunNumber()) ;
 923                 rawReader->RewindEvents() ;
 924         }
 925
 926         if (!fCycleSame)
 927     if ( !InitQA(AliQA::kRAWS) )
 928       return kFALSE ;
 929   fRawReaderDelete = kFALSE ;
 930
 931         DoIt(AliQA::kRAWS) ;
 932         return  fDetectorsW ;
 933 }
 934
 935 //_____________________________________________________________________________
 936 TString AliQAManager::Run(const char * detectors, const char * fileName, const Bool_t sameCycle)
 937 {
 938         //Runs all the QA data Maker for Raws only
 939
 940         fCycleSame       = sameCycle ;
 941         fDetectors       = detectors ;
 942         fDetectorsW      = detectors ;
 943
 944         AliCDBManager* man = AliCDBManager::Instance() ;
 945         if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
 946                 AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
 947                 if ( ! rl ) {
 948                         AliFatal("galice.root file not found in current directory") ;
 949                 } else {
 950                         rl->CdGAFile() ;
 951                         rl->LoadgAlice() ;
 952                         if ( ! rl->GetAliRun() ) {
 953                                 AliFatal("AliRun not found in galice.root") ;
 954                         } else {
 955                                 rl->LoadHeader() ;
 956                                 man->SetRun(rl->GetHeader()->GetRun());
 957                         }
 958                 }
 959         }
 960
 961         if (!fCycleSame)
 962     if ( !InitQA(AliQA::kRAWS, fileName) )
 963       return kFALSE ;
 964
 965         DoIt(AliQA::kRAWS) ;
 966         return  fDetectorsW ;
 967 }
 968
 969 //_____________________________________________________________________________
 970 TString AliQAManager::Run(const char * detectors, const AliQA::TASKINDEX_t taskIndex, Bool_t const sameCycle, const  char * fileName )
 971 {
 972         // Runs all the QA data Maker for every detector
 973
 974         fCycleSame       = sameCycle ;
 975         fDetectors       = detectors ;
 976         fDetectorsW      = detectors ;
 977
 978         AliCDBManager* man = AliCDBManager::Instance() ;
 979         if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
 980                 AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
 981                 if ( ! rl ) {
 982                         AliFatal("galice.root file not found in current directory") ;
 983                 } else {
 984                         rl->CdGAFile() ;
 985                         rl->LoadgAlice() ;
 986                         if ( ! rl->GetAliRun() ) {
 987                                 AliInfo("AliRun not found in galice.root") ;
 988                         } else {
 989                                 rl->LoadHeader() ;
 990                                 man->SetRun(rl->GetHeader()->GetRun()) ;
 991                         }
 992                 }
 993         }
 994
 995
 996         if ( taskIndex == AliQA::kNULLTASKINDEX) {
 997                 for (UInt_t task = 0; task < AliQA::kNTASKINDEX; task++) {
 998                         if ( fTasks.Contains(Form("%d", task)) ) {
 999         if (!fCycleSame)
1000           if ( !InitQA(AliQA::GetTaskIndex(AliQA::GetTaskName(task)), fileName) )
1001             return kFALSE ;
1002         DoIt(AliQA::GetTaskIndex(AliQA::GetTaskName(task))) ;
1003                         }
1004                 }
1005         } else {
1006     if (! fCycleSame )
1007       if ( !InitQA(taskIndex, fileName) )
1008         return kFALSE ;
1009       DoIt(taskIndex) ;
1010   }
1011
1012         return fDetectorsW ;
1013
1014 }
1015
1016 //_____________________________________________________________________________
1017 void AliQAManager::RunOneEvent(AliRawReader * rawReader)
1018 {
1019         //Runs all the QA data Maker for Raws only and on one event only (event loop done by calling method)
1020   if ( ! rawReader )
1021     return ;
1022         AliCodeTimerAuto("") ;
1023   if (fTasks.Contains(Form("%d", AliQA::kRAWS))){
1024     for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1025       if (!IsSelected(AliQA::GetDetName(iDet)))
1026         continue;
1027       AliQADataMaker *qadm = GetQADataMaker(iDet);
1028       if (!qadm)
1029         continue;
1030       if ( qadm->IsCycleDone() ) {
1031         qadm->EndOfCycle() ;
1032       }
1033       AliCodeTimerStart(Form("running RAW quality assurance data maker for %s", AliQA::GetDetName(iDet)));
1034       qadm->SetEventSpecie(fEventSpecie) ;
1035                         qadm->Exec(AliQA::kRAWS, rawReader) ;
1036       AliCodeTimerStop(Form("running RAW quality assurance data maker for %s", AliQA::GetDetName(iDet)));
1037                 }
1038   }
1039 }
1040
1041 //_____________________________________________________________________________
1042 void AliQAManager::RunOneEvent(AliESDEvent *& esd)
1043 {
1044         //Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
1045
1046   AliCodeTimerAuto("") ;
1047   if (fTasks.Contains(Form("%d", AliQA::kESDS))) {
1048     for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1049       if (!IsSelected(AliQA::GetDetName(iDet)))
1050         continue;
1051       AliQADataMaker *qadm = GetQADataMaker(iDet);
1052       if (!qadm)
1053         continue;
1054       if ( qadm->IsCycleDone() ) {
1055         qadm->EndOfCycle() ;
1056       }
1057       AliCodeTimerStart(Form("running ESD quality assurance data maker for %s", AliQA::GetDetName(iDet)));
1058                         qadm->Exec(AliQA::kESDS, esd) ;
1059       AliCodeTimerStop(Form("running ESD quality assurance data maker for %s", AliQA::GetDetName(iDet)));
1060                 }
1061         }
1062 }
1063
1064 //_____________________________________________________________________________
1065 void AliQAManager::RunOneEventInOneDetector(Int_t det, TTree * tree)
1066 {
1067         // Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
1068         AliCodeTimerAuto("") ;
1069   if (fTasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
1070     if (IsSelected(AliQA::GetDetName(det))) {
1071       AliQADataMaker *qadm = GetQADataMaker(det);
1072       if (qadm) {
1073         if ( qadm->IsCycleDone() ) {
1074           qadm->EndOfCycle() ;
1075         }
1076         AliCodeTimerStart(Form("running RecPoints quality assurance data maker for %s", AliQA::GetDetName(det)));
1077         qadm->Exec(AliQA::kRECPOINTS, tree) ;
1078         AliCodeTimerStop(Form("running RecPoints quality assurance data maker for %s", AliQA::GetDetName(det)));
1079       }
1080     }
1081   }
1082 }
1083
1084 //_____________________________________________________________________________
1085 Bool_t AliQAManager::Save2OCDB(const Int_t runNumber, AliRecoParam::EventSpecie_t es, const char * year, const char * detectors) const
1086 {
1087         // take the locasl QA data merge into a single file and save in OCDB
1088         Bool_t rv = kTRUE ;
1089         TString tmp(AliQA::GetQARefStorage()) ;
1090         if ( tmp.IsNull() ) {
1091                 AliError("No storage defined, use AliQA::SetQARefStorage") ;
1092                 return kFALSE ;
1093         }
1094         if ( !(tmp.Contains(AliQA::GetLabLocalOCDB()) || tmp.Contains(AliQA::GetLabAliEnOCDB())) ) {
1095                 AliError(Form("%s is a wrong storage, use %s or %s", AliQA::GetQARefStorage(), AliQA::GetLabLocalOCDB().Data(), AliQA::GetLabAliEnOCDB().Data())) ;
1096                 return kFALSE ;
1097         }
1098         TString sdet(detectors) ;
1099         sdet.ToUpper() ;
1100         TFile * inputFile ;
1101         if ( sdet.Contains("ALL") ) {
1102                 rv = Merge(runNumber) ;
1103                 if ( ! rv )
1104                         return kFALSE ;
1105                 TString inputFileName(Form("Merged.%s.Data.%d.root", AliQA::GetQADataFileName(), runNumber)) ;
1106                 inputFile = TFile::Open(inputFileName.Data()) ;
1107                 rv = SaveIt2OCDB(runNumber, inputFile, year, es) ;
1108         } else {
1109                 for (Int_t index = 0; index < AliQA::kNDET; index++) {
1110                         if (sdet.Contains(AliQA::GetDetName(index))) {
1111                                 TString inputFileName(Form("%s.%s.%d.root", AliQA::GetDetName(index), AliQA::GetQADataFileName(), runNumber)) ;
1112                                 inputFile = TFile::Open(inputFileName.Data()) ;
1113                                 rv *= SaveIt2OCDB(runNumber, inputFile, year, es) ;
1114                         }
1115                 }
1116         }
1117         return rv ;
1118 }
1119
1120 //_____________________________________________________________________________
1121 Bool_t AliQAManager::SaveIt2OCDB(const Int_t runNumber, TFile * inputFile, const char * year, AliRecoParam::EventSpecie_t es) const
1122 {
1123         // reads the TH1 from file and adds it to appropriate list before saving to OCDB
1124         Bool_t rv = kTRUE ;
1125         AliInfo(Form("Saving TH1s in %s to %s", inputFile->GetName(), AliQA::GetQARefStorage())) ;
1126         if ( ! IsDefaultStorageSet() ) {
1127                 TString tmp( AliQA::GetQARefStorage() ) ;
1128                 if ( tmp.Contains(AliQA::GetLabLocalOCDB()) )
1129                         Instance()->SetDefaultStorage(AliQA::GetQARefStorage()) ;
1130                 else {
1131                         TString tmp1(AliQA::GetQARefDefaultStorage()) ;
1132                         tmp1.Append(year) ;
1133                         tmp1.Append("?user=alidaq") ;
1134                         Instance()->SetDefaultStorage(tmp1.Data()) ;
1135                 }
1136         }
1137         Instance()->SetSpecificStorage("*", AliQA::GetQARefStorage()) ;
1138         if(GetRun() < 0)
1139                 Instance()->SetRun(runNumber);
1140
1141         AliCDBMetaData mdr ;
1142         mdr.SetResponsible("yves schutz");
1143
1144         for ( Int_t detIndex = 0 ; detIndex < AliQA::kNDET ; detIndex++) {
1145                 TDirectory * detDir = inputFile->GetDirectory(AliQA::GetDetName(detIndex)) ;
1146                 if ( detDir ) {
1147                         AliInfo(Form("Entering %s", detDir->GetName())) ;
1148       AliQA::SetQARefDataDirName(es) ;
1149                         TString detOCDBDir(Form("%s/%s/%s", AliQA::GetDetName(detIndex), AliQA::GetRefOCDBDirName(), AliQA::GetRefDataDirName())) ;
1150                         AliCDBId idr(detOCDBDir.Data(), runNumber, AliCDBRunRange::Infinity())  ;
1151                         TList * listDetQAD = new TList() ;
1152                         TString listName(Form("%s QA data Reference", AliQA::GetDetName(detIndex))) ;
1153                         mdr.SetComment(Form("%s QA stuff", AliQA::GetDetName(detIndex)));
1154                         listDetQAD->SetName(listName) ;
1155                         TList * taskList = detDir->GetListOfKeys() ;
1156                         TIter nextTask(taskList) ;
1157                         TKey * taskKey ;
1158                         while ( (taskKey = dynamic_cast<TKey*>(nextTask())) ) {
1159                                 TDirectory * taskDir = detDir->GetDirectory(taskKey->GetName()) ;
1160         TDirectory * esDir   = taskDir->GetDirectory(AliRecoParam::GetEventSpecieName(es)) ;
1161                                 AliInfo(Form("Saving %s", esDir->GetName())) ;
1162                                 TObjArray * listTaskQAD = new TObjArray(100) ;
1163                                 listTaskQAD->SetName(Form("%s/%s", taskKey->GetName(), AliRecoParam::GetEventSpecieName(es))) ;
1164                                 listDetQAD->Add(listTaskQAD) ;
1165                                 TList * histList = esDir->GetListOfKeys() ;
1166                                 TIter nextHist(histList) ;
1167                                 TKey * histKey ;
1168                                 while ( (histKey = dynamic_cast<TKey*>(nextHist())) ) {
1169                                         TObject * odata = esDir->Get(histKey->GetName()) ;
1170                                         if ( !odata ) {
1171                                                 AliError(Form("%s in %s/%s returns a NULL pointer !!", histKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
1172                                         } else {
1173             if ( AliQA::GetExpert() == histKey->GetName() ) {
1174               TDirectory * expertDir   = esDir->GetDirectory(histKey->GetName()) ;
1175               TList * expertHistList = expertDir->GetListOfKeys() ;
1176               TIter nextExpertHist(expertHistList) ;
1177               TKey * expertHistKey ;
1178               while ( (expertHistKey = dynamic_cast<TKey*>(nextExpertHist())) ) {
1179                 TObject * expertOdata = expertDir->Get(expertHistKey->GetName()) ;
1180                 if ( !expertOdata ) {
1181                   AliError(Form("%s in %s/%s/Expert returns a NULL pointer !!", expertHistKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
1182                 } else {
1183                   AliInfo(Form("Adding %s", expertHistKey->GetName())) ;
1184                   if ( expertOdata->IsA()->InheritsFrom("TH1") ) {
1185                     AliInfo(Form("Adding %s", expertHistKey->GetName())) ;
1186                     TH1 * hExpertdata = static_cast<TH1*>(expertOdata) ;
1187                     listTaskQAD->Add(hExpertdata) ;
1188                   }
1189                 }
1190               }
1191             }
1192                                                 AliInfo(Form("Adding %s", histKey->GetName())) ;
1193                                                 if ( odata->IsA()->InheritsFrom("TH1") ) {
1194                                                         AliInfo(Form("Adding %s", histKey->GetName())) ;
1195                                                         TH1 * hdata = static_cast<TH1*>(odata) ;
1196                                                         listTaskQAD->Add(hdata) ;
1197                                                 }
1198                                         }
1199                                 }
1200                         }
1201                         Instance()->Put(listDetQAD, idr, &mdr) ;
1202                 }
1203         }
1204         return rv ;
1205 }
1206
1207 //_____________________________________________________________________________
1208 void AliQAManager::SetEventSpecie(AliRecoParam::EventSpecie_t es)
1209 {
1210   // set the current event specie and inform AliQA that this event specie has been encountered
1211   fEventSpecie = es ;
1212   AliQA::Instance()->SetEventSpecie(es) ;
1213 }
1214
1215 //_____________________________________________________________________________
1216 void AliQAManager::SetRecoParam(const Int_t det, const AliDetectorRecoParam *par)
1217 {
1218   // Set custom reconstruction parameters for a given detector
1219   // Single set of parameters for all the events
1220   GetQADataMaker(det)->SetRecoParam(par) ;
1221 }
1222
1223