STEER/AliQADataMakerSteer.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$ */
  17 ///////////////////////////////////////////////////////////////////////////////
  18 //                                                                           //
  19 // class for running the QA makers                                           //
  20 //                                                                           //
  21 //   AliQADataMakerSteer 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 <TKey.h>
  32 #include <TFile.h>
  33 #include <TFileMerger.h>
  34 #include <TPluginManager.h>
  35 #include <TROOT.h>
  36 #include <TString.h>
  37 #include <TSystem.h>
  38
  39 #include "AliCDBManager.h"
  40 #include "AliCDBEntry.h"
  41 #include "AliCDBId.h"
  42 #include "AliCDBMetaData.h"
  43 #include "AliESDEvent.h"
  44 #include "AliHeader.h"
  45 #include "AliLog.h"
  46 #include "AliModule.h"
  47 #include "AliQA.h"
  48 #include "AliQADataMakerRec.h"
  49 #include "AliQADataMakerSim.h"
  50 #include "AliQADataMakerSteer.h"
  51 #include "AliRawReaderDate.h"
  52 #include "AliRawReaderFile.h"
  53 #include "AliRawReaderRoot.h"
  54 #include "AliRun.h"
  55 #include "AliRunLoader.h"
  56
  57 ClassImp(AliQADataMakerSteer)
  58
  59 //_____________________________________________________________________________
  60 AliQADataMakerSteer::AliQADataMakerSteer(const char* gAliceFilename, const char * name, const char * title) :
  61         TNamed(name, title),
  62         fCurrentEvent(0),
  63         fCycleSame(kFALSE),
  64         fDetectors("ALL"),
  65         fDetectorsW("ALL"),
  66         fESD(NULL),
  67         fESDTree(NULL),
  68         fFirst(kTRUE),
  69         fGAliceFileName(gAliceFilename),
  70         fFirstEvent(0),
  71         fMaxEvents(0),
  72         fNumberOfEvents(999999),
  73     fRunNumber(0),
  74         fRawReader(NULL),
  75         fRawReaderDelete(kTRUE),
  76         fRunLoader(NULL),
  77         fQADataMakers()
  78
  79 {
  80         // default ctor
  81         fMaxEvents = fNumberOfEvents ;
  82         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
  83                 if (IsSelected(AliQA::GetDetName(iDet))) {
  84                         fLoader[iDet]      = NULL ;
  85                         fQADataMaker[iDet] = NULL ;
  86                         fQACycles[iDet]    = 999999 ;
  87                 }
  88         }
  89 }
  90
  91 //_____________________________________________________________________________
  92 AliQADataMakerSteer::AliQADataMakerSteer(const AliQADataMakerSteer & qas) :
  93         TNamed(qas),
  94         fCurrentEvent(qas.fCurrentEvent),
  95         fCycleSame(kFALSE),
  96         fDetectors(qas.fDetectors),
  97         fDetectorsW(qas.fDetectorsW),
  98         fESD(NULL),
  99         fESDTree(NULL),
 100         fFirst(qas.fFirst),
 101         fGAliceFileName(qas.fGAliceFileName),
 102         fFirstEvent(qas.fFirstEvent),
 103         fMaxEvents(qas.fMaxEvents),
 104         fNumberOfEvents(qas.fNumberOfEvents),
 105     fRunNumber(qas.fRunNumber),
 106         fRawReader(NULL),
 107         fRawReaderDelete(kTRUE),
 108         fRunLoader(NULL),
 109         fQADataMakers()
 110 {
 111         // cpy ctor
 112         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 113                 fLoader[iDet]      = qas.fLoader[iDet] ;
 114                 fQADataMaker[iDet] = qas.fQADataMaker[iDet] ;
 115                 fQACycles[iDet]    = qas.fQACycles[iDet] ;
 116         }
 117 }
 118
 119 //_____________________________________________________________________________
 120 AliQADataMakerSteer & AliQADataMakerSteer::operator = (const AliQADataMakerSteer & qas)
 121 {
 122         // assignment operator
 123   this->~AliQADataMakerSteer() ;
 124   new(this) AliQADataMakerSteer(qas) ;
 125   return *this ;
 126 }
 127
 128 //_____________________________________________________________________________
 129 AliQADataMakerSteer::~AliQADataMakerSteer()
 130 {
 131         // dtor
 132   for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 133           if (IsSelected(AliQA::GetDetName(iDet))) {
 134                   fLoader[iDet] = NULL;
 135                   if (fQADataMaker[iDet]) {
 136                           (fQADataMaker[iDet])->Finish() ;
 137                           delete fQADataMaker[iDet] ;
 138                           fQADataMaker[iDet] = NULL ;
 139                   }
 140           }
 141   }
 142
 143   if (fRawReaderDelete) {
 144         fRunLoader = NULL ;
 145         delete fRawReader ;
 146         fRawReader = NULL ;
 147   }
 148 }
 149
 150 //_____________________________________________________________________________
 151 Bool_t AliQADataMakerSteer::DoIt(const AliQA::TASKINDEX_t taskIndex, const char * mode)
 152 {
 153         // Runs all the QA data Maker for every detector
 154
 155         Bool_t rv = kFALSE ;
 156     // Fill QA data in event loop
 157         for (UInt_t iEvent = fFirstEvent ; iEvent < (UInt_t)fMaxEvents ; iEvent++) {
 158                 fCurrentEvent++ ;
 159                 // Get the event
 160                 if ( iEvent%10 == 0  )
 161                         AliInfo(Form("processing event %d", iEvent));
 162                 if ( taskIndex == AliQA::kRAWS ) {
 163                         if ( !fRawReader->NextEvent() )
 164                                 break ;
 165                 } else if ( taskIndex == AliQA::kESDS ) {
 166                         if ( fESDTree->GetEntry(iEvent) == 0 )
 167                                 break ;
 168                 } else {
 169                         if ( fRunLoader->GetEvent(iEvent) != 0 )
 170                                 break ;
 171                 }
 172                 // loop  over active loaders
 173                 for (Int_t i = 0; i < fQADataMakers.GetEntriesFast() ; i++) {
 174                         AliQADataMaker * qadm = static_cast<AliQADataMaker *>(fQADataMakers.At(i)) ;
 175                         if ( qadm->IsCycleDone() ) {
 176                                 qadm->EndOfCycle(AliQA::kRAWS) ;
 177                                 qadm->StartOfCycle(AliQA::kRAWS) ;
 178                         }
 179                         TTree * data ;
 180                         Int_t iDet = qadm->GetUniqueID();
 181                         AliLoader* loader = GetLoader(iDet);
 182                         switch (taskIndex) {
 183                                 case AliQA::kRAWS :
 184                                         qadm->Exec(taskIndex, fRawReader) ;
 185                                         break ;
 186                                 case AliQA::kHITS :
 187                                         loader->LoadHits() ;
 188                                         data = loader->TreeH() ;
 189                                         if ( ! data ) {
 190                                                 AliWarning(Form(" Hit Tree not found for  %s", AliQA::GetDetName(iDet))) ;
 191                                         } else {
 192                                                 qadm->Exec(taskIndex, data) ;
 193                                         }
 194                                         break ;
 195                                         case AliQA::kSDIGITS :
 196                                         loader->LoadSDigits() ;
 197                                         data = loader->TreeS() ;
 198                                         if ( ! data ) {
 199                                                 AliWarning(Form(" SDigit Tree not found for  %s", AliQA::GetDetName(iDet))) ;
 200                                         } else {
 201                                                 qadm->Exec(taskIndex, data) ;
 202                                         }
 203                                         break;
 204                                         case AliQA::kDIGITS :
 205                                         loader->LoadDigits() ;
 206                                         data = loader->TreeD() ;
 207                                         if ( ! data ) {
 208                                                 AliWarning(Form(" Digit Tree not found for  %s", AliQA::GetDetName(iDet))) ;
 209                                         } else {
 210                                                 qadm->Exec(taskIndex, data) ;
 211                                         }
 212                                         break;
 213                                         case AliQA::kRECPOINTS :
 214                                         loader->LoadRecPoints() ;
 215                                         data = loader->TreeR() ;
 216                                         if (!data) {
 217                                                 AliWarning(Form("RecPoints not found for %s", AliQA::GetDetName(iDet))) ;
 218                                         } else {
 219                                                 qadm->Exec(taskIndex, data) ;
 220                                         }
 221                                         break;
 222                                         case AliQA::kTRACKSEGMENTS :
 223                                         break;
 224                                         case AliQA::kRECPARTICLES :
 225                                         break;
 226                                         case AliQA::kESDS :
 227                                         qadm->Exec(taskIndex, fESD) ;
 228                                         break;
 229                                         case AliQA::kNTASKINDEX :
 230                                         break;
 231                         } //task switch
 232                         //qadm->Increment() ;
 233                 } // detector loop
 234         } // event loop
 235 //      // Save QA data for all detectors
 236         rv = Finish(taskIndex, mode) ;
 237
 238         return rv ;
 239 }
 240
 241 //_____________________________________________________________________________
 242 Bool_t AliQADataMakerSteer::Finish(const AliQA::TASKINDEX_t taskIndex, const char * /*mode*/)
 243 {
 244         // write output to file for all detectors
 245         for (Int_t i = 0; i < fQADataMakers.GetEntriesFast() ; i++) {
 246                 AliQADataMaker * qadm = static_cast<AliQADataMaker *>(fQADataMakers.At(i));
 247                 qadm->EndOfCycle(taskIndex) ;
 248         }
 249         return kTRUE ;
 250 }
 251
 252 //_____________________________________________________________________________
 253 TObjArray * AliQADataMakerSteer::GetFromOCDB(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, const char * year) const
 254 {
 255         // Retrieve the list of QA data for a given detector and a given task
 256         TObjArray * rv = NULL ;
 257         TString tmp(AliQA::GetQARefStorage()) ;
 258         if ( tmp.IsNull() ) {
 259                 AliError("No storage defined, use AliQA::SetQARefStorage") ;
 260                 return NULL ;
 261         }
 262         AliCDBManager* man = AliCDBManager::Instance() ;
 263         if ( ! man->IsDefaultStorageSet() ) {
 264                 TString tmp(AliQA::GetQARefDefaultStorage()) ;
 265                 tmp.Append(year) ;
 266                 tmp.Append("/") ;
 267                 man->SetDefaultStorage(tmp.Data()) ;
 268                 man->SetSpecificStorage(Form("%s/*", AliQA::GetQAName()), AliQA::GetQARefStorage()) ;
 269         }
 270         TString detOCDBDir(Form("%s/%s/%s", AliQA::GetQAName(), AliQA::GetDetName((Int_t)det), AliQA::GetRefOCDBDirName())) ;
 271         AliInfo(Form("Retrieving reference data from %s/%s for %s", AliQA::GetQARefStorage(), detOCDBDir.Data(), AliQA::GetTaskName(task).Data())) ;
 272         AliCDBEntry* entry = man->Get(detOCDBDir.Data(), 0) ; //FIXME 0 --> Run Number
 273         TList * listDetQAD = dynamic_cast<TList *>(entry->GetObject()) ;
 274         if ( listDetQAD )
 275                 rv = dynamic_cast<TObjArray *>(listDetQAD->FindObject(AliQA::GetTaskName(task))) ;
 276         return rv ;
 277 }
 278
 279 //_____________________________________________________________________________
 280 AliLoader * AliQADataMakerSteer::GetLoader(Int_t iDet)
 281 {
 282         // get the loader for a detector
 283
 284         if ( !fRunLoader )
 285                 return NULL ;
 286
 287         TString detName = AliQA::GetDetName(iDet) ;
 288     fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
 289         if (fLoader[iDet])
 290                 return fLoader[iDet] ;
 291
 292         // load the QA data maker object
 293         TPluginManager* pluginManager = gROOT->GetPluginManager() ;
 294         TString loaderName = "Ali" + detName + "Loader" ;
 295
 296         AliLoader * loader = NULL ;
 297         // first check if a plugin is defined for the quality assurance data maker
 298         TPluginHandler* pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
 299         // if not, add a plugin for it
 300         if (!pluginHandler) {
 301                 AliDebug(1, Form("defining plugin for %s", loaderName.Data())) ;
 302                 TString libs = gSystem->GetLibraries() ;
 303                 if (libs.Contains("lib" + detName + "base.so") || (gSystem->Load("lib" + detName + "base.so") >= 0)) {
 304                         pluginManager->AddHandler("AliQADataMaker", detName, loaderName, detName + "loader", loaderName + "()") ;
 305                 } else {
 306                         pluginManager->AddHandler("AliLoader", detName, loaderName, detName, loaderName + "()") ;
 307                 }
 308                 pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
 309         }
 310         if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
 311                 loader = (AliLoader *) pluginHandler->ExecPlugin(0) ;
 312         }
 313         if (loader)
 314                 fLoader[iDet] = loader ;
 315         return loader ;
 316 }
 317
 318 //_____________________________________________________________________________
 319 AliQADataMaker * AliQADataMakerSteer::GetQADataMaker(const Int_t iDet, const char * mode )
 320 {
 321         // get the quality assurance data maker for a detector
 322
 323         if (fQADataMaker[iDet])
 324                 return fQADataMaker[iDet] ;
 325
 326         AliQADataMaker * qadm = NULL ;
 327
 328         if (fFirst) {
 329                 // load the QA data maker object
 330                 TPluginManager* pluginManager = gROOT->GetPluginManager() ;
 331                 TString detName = AliQA::GetDetName(iDet) ;
 332                 TString tmp(mode) ;
 333                 if (tmp.Contains("sim"))
 334                         tmp.ReplaceAll("s", "S") ;
 335                 else if (tmp.Contains("rec"))
 336                         tmp.ReplaceAll("r", "R") ;
 337                 TString qadmName = "Ali" + detName + "QADataMaker" + tmp ;
 338
 339                 // first check if a plugin is defined for the quality assurance data maker
 340                 TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
 341                 // if not, add a plugin for it
 342                 if (!pluginHandler) {
 343                         AliDebug(1, Form("defining plugin for %s", qadmName.Data())) ;
 344                         TString libs = gSystem->GetLibraries() ;
 345                         if (libs.Contains("lib" + detName + mode + ".so") || (gSystem->Load("lib" + detName + mode + ".so") >= 0)) {
 346                                 pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName + "qadm", qadmName + "()") ;
 347                         } else {
 348                                 pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName, qadmName + "()") ;
 349                         }
 350                         pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
 351                 }
 352                 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
 353                         qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0) ;
 354                 }
 355                 if (qadm)
 356                         fQADataMaker[iDet] = qadm ;
 357         }
 358         return qadm ;
 359 }
 360
 361 //_____________________________________________________________________________
 362 Bool_t AliQADataMakerSteer::Init(const AliQA::TASKINDEX_t taskIndex, const char * mode, const  char * input )
 363 {
 364         // Initialize the event source and QA data makers
 365
 366         if (taskIndex == AliQA::kRAWS) {
 367                 if (!fRawReader) {
 368                         fRawReader = AliRawReader::Create(input);
 369                 }
 370             if ( ! fRawReader )
 371                         return kFALSE ;
 372                 fRawReaderDelete = kTRUE ;
 373                 fRawReader->NextEvent() ;
 374                 fRunNumber = fRawReader->GetRunNumber() ;
 375                 AliCDBManager::Instance()->SetRun(fRunNumber) ;
 376                 fRawReader->RewindEvents();
 377                 fNumberOfEvents = 999999 ;
 378                 if ( fMaxEvents < 0 )
 379                         fMaxEvents = fNumberOfEvents ;
 380                 } else if (taskIndex == AliQA::kESDS) {
 381                 if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
 382                         TFile * esdFile = TFile::Open("AliESDs.root") ;
 383                         fESDTree = dynamic_cast<TTree *> (esdFile->Get("esdTree")) ;
 384                         if ( !fESDTree ) {
 385                                 AliError("esdTree not found") ;
 386                                 return kFALSE ;
 387                         } else {
 388                                 fESD     = new AliESDEvent() ;
 389                                 fESD->ReadFromTree(fESDTree) ;
 390                                 fESDTree->GetEntry(0) ;
 391                                 fRunNumber = fESD->GetRunNumber() ;
 392                                 fNumberOfEvents = fESDTree->GetEntries() ;
 393                                 if ( fMaxEvents < 0 )
 394                                         fMaxEvents = fNumberOfEvents ;
 395                         }
 396                 } else {
 397                         AliError("AliESDs.root not found") ;
 398                         return kFALSE ;
 399                 }
 400                 } else {
 401                 if ( !InitRunLoader() ) {
 402                         AliWarning("No Run Loader not found") ;
 403                 } else {
 404                         fNumberOfEvents = fRunLoader->GetNumberOfEvents() ;
 405                         if ( fMaxEvents < 0 )
 406                                 fMaxEvents = fNumberOfEvents ;
 407
 408                 }
 409         }
 410
 411         // Get Detectors
 412         TObjArray* detArray = NULL ;
 413         if (fRunLoader) // check if RunLoader exists
 414                 if ( fRunLoader->GetAliRun() ) { // check if AliRun exists in gAlice.root
 415                         detArray = fRunLoader->GetAliRun()->Detectors() ;
 416                         fRunNumber = fRunLoader->GetHeader()->GetRun() ;
 417                 }
 418         // Build array of QA data makers for all detectors
 419         fQADataMakers.Clear();
 420         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
 421                 if (IsSelected(AliQA::GetDetName(iDet))) {
 422                         AliQADataMaker * qadm = GetQADataMaker(iDet, mode) ;
 423                         if (!qadm) {
 424                                 AliError(Form("AliQADataMaker not found for %s", AliQA::GetDetName(iDet))) ;
 425                                 fDetectorsW.ReplaceAll(AliQA::GetDetName(iDet), "") ;
 426                         } else {
 427                                 AliDebug(1, Form("Data Maker found for %s", qadm->GetName())) ;
 428                                 // skip non active detectors
 429                                 if (detArray) {
 430                                         AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQA::GetDetName(iDet))) ;
 431                                         if (!det || !det->IsActive())
 432                                                 continue ;
 433                                 }
 434                                 qadm->SetName(AliQA::GetDetName(iDet));
 435                                 qadm->SetUniqueID(iDet);
 436                                 fQADataMakers.Add(qadm);
 437                         }
 438                 }
 439         }
 440         // Initialize all QA data makers for all detectors
 441         fRunNumber = AliCDBManager::Instance()->GetRun() ;
 442         for (Int_t i = 0; i < fQADataMakers.GetEntriesFast() ; i++) {
 443                 AliQADataMaker * qadm = static_cast<AliQADataMaker *>(fQADataMakers.At(i));
 444                 qadm->Init(taskIndex, fRunNumber, GetQACycles(qadm->GetUniqueID())) ;
 445                 qadm->StartOfCycle(taskIndex, fCycleSame) ;
 446         }
 447         fFirst = kFALSE ;
 448         return kTRUE ;
 449 }
 450
 451 //_____________________________________________________________________________
 452 Bool_t AliQADataMakerSteer::InitRunLoader()
 453 {
 454         // get or create the run loader
 455         if (fRunLoader) {
 456                 fCycleSame = kTRUE ;
 457         } else {
 458                 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
 459                         // load all base libraries to get the loader classes
 460                         TString libs = gSystem->GetLibraries() ;
 461                         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 462                                 if (!IsSelected(AliQA::GetDetName(iDet)))
 463                                         continue ;
 464                                 TString detName = AliQA::GetDetName(iDet) ;
 465                                 if (detName == "HLT")
 466                                         continue;
 467                                 if (libs.Contains("lib" + detName + "base.so"))
 468                                         continue;
 469                                 gSystem->Load("lib" + detName + "base.so");
 470                         }
 471                         fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
 472                         if (!fRunLoader) {
 473                                 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
 474                                 return kFALSE;
 475                         }
 476                         fRunLoader->CdGAFile();
 477                         if (fRunLoader->LoadgAlice() == 0) {
 478                                 gAlice = fRunLoader->GetAliRun();
 479                         }
 480
 481                         if (!gAlice) {
 482                                 AliError(Form("no gAlice object found in file %s", fGAliceFileName.Data()));
 483                                 return kFALSE;
 484                         }
 485
 486                 } else {               // galice.root does not exist
 487                         AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
 488                         return kFALSE;
 489                 }
 490         }
 491
 492         if (!fRunNumber) {
 493                 fRunLoader->LoadHeader();
 494                 fRunNumber = fRunLoader->GetHeader()->GetRun() ;
 495         }
 496         return kTRUE;
 497 }
 498
 499 //_____________________________________________________________________________
 500 Bool_t AliQADataMakerSteer::IsSelected(const char * det)
 501 {
 502         // check whether detName is contained in detectors
 503         // if yes, it is removed from detectors
 504
 505         Bool_t rv = kFALSE;
 506         const TString detName(det) ;
 507         // check if all detectors are selected
 508         if (fDetectors.Contains("ALL")) {
 509                 fDetectors = "ALL";
 510                 rv = kTRUE;
 511         } else if ((fDetectors.CompareTo(detName) == 0) ||
 512                            fDetectors.BeginsWith(detName+" ") ||
 513                            fDetectors.EndsWith(" "+detName) ||
 514                            fDetectors.Contains(" "+detName+" ")) {
 515                 //              fDetectors.ReplaceAll(detName, "");
 516                 rv = kTRUE;
 517         }
 518
 519         // clean up the detectors string
 520         //      while (fDetectors.Contains("  "))
 521         //              fDetectors.ReplaceAll("  ", " ");
 522         //      while (fDetectors.BeginsWith(" "))
 523         //              fDetectors.Remove(0, 1);
 524         //      while (fDetectors.EndsWith(" "))
 525         //              fDetectors.Remove(fDetectors.Length()-1, 1);
 526
 527         return rv ;
 528 }
 529
 530 //_____________________________________________________________________________
 531 Bool_t AliQADataMakerSteer::Merge(const Int_t runNumber) const
 532 {
 533         // Merge all the cycles from all detectors in one single file per run
 534         TString cmd ;
 535         if ( runNumber == -1 )
 536                 cmd = Form(".! ls *%s*.*.*.root > tempo.txt", AliQA::GetQADataFileName()) ;
 537         else
 538                 cmd = Form(".! ls *%s*.%d.*.root > tempo.txt", AliQA::GetQADataFileName(), runNumber) ;
 539         gROOT->ProcessLine(cmd.Data()) ;
 540         ifstream in("tempo.txt") ;
 541         const Int_t runMax = 10 ;
 542         TString file[AliQA::kNDET*runMax] ;
 543         Int_t run[AliQA::kNDET*runMax] = {-1} ;
 544
 545         Int_t index = 0 ;
 546         while ( 1 ) {
 547                 in >> file[index] ;
 548                 if ( !in.good() )
 549                         break ;
 550                 AliInfo(Form("index = %d file = %s", index, (file[index]).Data())) ;
 551                 index++ ;
 552         }
 553
 554         if ( index == 0 ) {
 555                 AliError(Form("run number %d not found", runNumber)) ;
 556                 return kFALSE ;
 557         }
 558
 559         Int_t runIndex    = 0 ;
 560         Int_t runIndexMax = 0 ;
 561         TString stmp(Form(".%s.", AliQA::GetQADataFileName())) ;
 562         for (Int_t ifile = 0 ; ifile < index ; ifile++) {
 563                 TString tmp(file[ifile]) ;
 564                 tmp.ReplaceAll(".root", "") ;
 565                 TString det = tmp(0, tmp.Index(".")) ;
 566                 tmp.Remove(0, tmp.Index(stmp)+4) ;
 567                 TString ttmp = tmp(0, tmp.Index(".")) ;
 568                 Int_t newRun = ttmp.Atoi() ;
 569                 for (Int_t irun = 0; irun <= runIndexMax; irun++) {
 570                         if (newRun == run[irun])
 571                                 break ;
 572                         run[runIndex] = newRun ;
 573                         runIndex++ ;
 574                 }
 575                 runIndexMax = runIndex ;
 576                 ttmp = tmp(tmp.Index(".")+1, tmp.Length()) ;
 577                 Int_t cycle = ttmp.Atoi() ;
 578                 AliDebug(1, Form("%s : det = %s run = %d cycle = %d \n", file[ifile].Data(), det.Data(), newRun, cycle)) ;
 579         }
 580         for (Int_t irun = 0 ; irun < runIndexMax ; irun++) {
 581                 TFileMerger merger ;
 582                 TString outFileName(Form("Merged.%s.%d.root",AliQA::GetQADataFileName(),run[irun]));
 583                 merger.OutputFile(outFileName.Data()) ;
 584                 for (Int_t ifile = 0 ; ifile < index-1 ; ifile++) {
 585                         TString pattern(Form("%s.%d.", AliQA::GetQADataFileName(), run[irun])) ;
 586                         TString tmp(file[ifile]) ;
 587                         if (tmp.Contains(pattern)) {
 588                                 merger.AddFile(tmp) ;
 589                         }
 590                 }
 591                 merger.Merge() ;
 592         }
 593
 594         return kTRUE ;
 595 }
 596
 597 //_____________________________________________________________________________
 598 void AliQADataMakerSteer::Reset(const Bool_t sameCycle)
 599 {
 600         // Reset the default data members
 601
 602         for (Int_t i = 0; i < fQADataMakers.GetEntriesFast() ; i++) {
 603                 AliQADataMaker * qadm = static_cast<AliQADataMaker *>(fQADataMakers.At(i));
 604                 qadm->Reset(sameCycle);
 605         }
 606         if (fRawReaderDelete) {
 607                 delete fRawReader ;
 608                 fRawReader      = NULL ;
 609         }
 610
 611         fCycleSame      = sameCycle ;
 612         fESD            = NULL ;
 613         fESDTree        = NULL ;
 614         fFirst          = kTRUE ;
 615         fNumberOfEvents = 999999 ;
 616 }
 617
 618 //_____________________________________________________________________________
 619 TString AliQADataMakerSteer::Run(const char * detectors, AliRawReader * rawReader, const Bool_t sameCycle)
 620 {
 621         //Runs all the QA data Maker for Raws only
 622
 623         fCycleSame       = sameCycle ;
 624         fRawReader       = rawReader ;
 625         fDetectors       = detectors ;
 626         fDetectorsW      = detectors ;
 627
 628         AliCDBManager* man = AliCDBManager::Instance() ;
 629
 630         if ( man->GetRun() == -1 ) {// check if run number not set previously and set it from raw data
 631                 rawReader->NextEvent() ;
 632                 man->SetRun(fRawReader->GetRunNumber()) ;
 633                 rawReader->RewindEvents() ;
 634         }
 635
 636         if ( !Init(AliQA::kRAWS, "rec") )
 637                 return kFALSE ;
 638         fRawReaderDelete = kFALSE ;
 639
 640         DoIt(AliQA::kRAWS, "rec") ;
 641         return  fDetectorsW ;
 642 }
 643
 644 //_____________________________________________________________________________
 645 TString AliQADataMakerSteer::Run(const char * detectors, const char * fileName, const Bool_t sameCycle)
 646 {
 647         //Runs all the QA data Maker for Raws only
 648
 649         fCycleSame       = sameCycle ;
 650         fDetectors       = detectors ;
 651         fDetectorsW      = detectors ;
 652
 653         AliCDBManager* man = AliCDBManager::Instance() ;
 654         if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
 655                 AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
 656                 if ( ! rl ) {
 657                         AliFatal("galice.root file not found in current directory") ;
 658                 } else {
 659                         rl->CdGAFile() ;
 660                         rl->LoadgAlice() ;
 661                         if ( ! rl->GetAliRun() ) {
 662                                 AliFatal("AliRun not found in galice.root") ;
 663                         } else {
 664                                 rl->LoadHeader() ;
 665                                 man->SetRun(rl->GetHeader()->GetRun());
 666                         }
 667                 }
 668         }
 669
 670         if ( !Init(AliQA::kRAWS, "rec", fileName) )
 671                 return kFALSE ;
 672
 673         DoIt(AliQA::kRAWS, "rec") ;
 674         return  fDetectorsW ;
 675 }
 676
 677 //_____________________________________________________________________________
 678 TString AliQADataMakerSteer::Run(const char * detectors, const AliQA::TASKINDEX_t taskIndex, Bool_t const sameCycle, const  char * fileName )
 679 {
 680         // Runs all the QA data Maker for every detector
 681
 682         fCycleSame       = sameCycle ;
 683         fDetectors       = detectors ;
 684         fDetectorsW      = detectors ;
 685
 686         TString mode ;
 687         if ( (taskIndex == AliQA::kHITS) || (taskIndex == AliQA::kSDIGITS) || (taskIndex == AliQA::kDIGITS) )
 688                 mode = "sim" ;
 689         else if ( (taskIndex == AliQA::kRAWS) || (taskIndex == AliQA::kRECPOINTS) || (taskIndex == AliQA::kESDS) )
 690                 mode = "rec" ;
 691         else {
 692                 AliError(Form("%s not implemented", AliQA::GetTaskName(taskIndex).Data())) ;
 693                 return "" ;
 694         }
 695
 696         AliCDBManager* man = AliCDBManager::Instance() ;
 697         if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
 698                 AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
 699                 if ( ! rl ) {
 700                         AliFatal("galice.root file not found in current directory") ;
 701                 } else {
 702                         rl->CdGAFile() ;
 703                         rl->LoadgAlice() ;
 704                         if ( ! rl->GetAliRun() ) {
 705                                 AliFatal("AliRun not found in galice.root") ;
 706                         } else {
 707                                 rl->LoadHeader() ;
 708                                 man->SetRun(rl->GetHeader()->GetRun()) ;
 709                         }
 710                 }
 711         }
 712
 713         if ( !Init(taskIndex, mode.Data(), fileName) )
 714                 return kFALSE ;
 715
 716         DoIt(taskIndex, mode.Data()) ;
 717
 718         return fDetectorsW ;
 719
 720 }
 721
 722 //_____________________________________________________________________________
 723 Bool_t AliQADataMakerSteer::Save2OCDB(const Int_t runNumber, const char * year, const Int_t cycleNumber, const char * detectors) const
 724 {
 725         // take the locasl QA data merge into a single file and save in OCDB
 726         Bool_t rv = kTRUE ;
 727         TString tmp(AliQA::GetQARefStorage()) ;
 728         if ( tmp.IsNull() ) {
 729                 AliError("No storage defined, use AliQA::SetQARefStorage") ;
 730                 return kFALSE ;
 731         }
 732         if ( !(tmp.Contains(AliQA::GetLabLocalOCDB()) || tmp.Contains(AliQA::GetLabAliEnOCDB())) ) {
 733                 AliError(Form("%s is a wrong storage, use %s or %s", AliQA::GetQARefStorage(), AliQA::GetLabLocalOCDB().Data(), AliQA::GetLabAliEnOCDB().Data())) ;
 734                 return kFALSE ;
 735         }
 736         TString sdet(detectors) ;
 737         sdet.ToUpper() ;
 738         TFile * inputFile ;
 739         if ( sdet.Contains("ALL") ) {
 740                 rv = Merge(runNumber) ;
 741                 if ( ! rv )
 742                         return kFALSE ;
 743                 TString inputFileName(Form("Merged.%s.%d.root", AliQA::GetQADataFileName(), runNumber)) ;
 744                 inputFile = TFile::Open(inputFileName.Data()) ;
 745                 rv = SaveIt2OCDB(runNumber, inputFile, year) ;
 746         } else {
 747                 for (Int_t index = 0; index < AliQA::kNDET; index++) {
 748                         if (sdet.Contains(AliQA::GetDetName(index))) {
 749                                 TString inputFileName(Form("%s.%s.%d.%d.root", AliQA::GetDetName(index), AliQA::GetQADataFileName(), runNumber, cycleNumber)) ;
 750                                 inputFile = TFile::Open(inputFileName.Data()) ;
 751                                 rv *= SaveIt2OCDB(runNumber, inputFile, year) ;
 752                         }
 753                 }
 754         }
 755         return rv ;
 756 }
 757
 758 //_____________________________________________________________________________
 759 Bool_t AliQADataMakerSteer::SaveIt2OCDB(const Int_t runNumber, TFile * inputFile, const char * year) const
 760 {
 761         // reads the TH1 from file and adds it to appropriate list before saving to OCDB
 762         Bool_t rv = kTRUE ;
 763         AliInfo(Form("Saving TH1s in %s to %s", inputFile->GetName(), AliQA::GetQARefStorage())) ;
 764         AliCDBManager* man = AliCDBManager::Instance() ;
 765         if ( ! man->IsDefaultStorageSet() ) {
 766                 TString tmp( AliQA::GetQARefStorage() ) ;
 767                 if ( tmp.Contains(AliQA::GetLabLocalOCDB()) )
 768                         man->SetDefaultStorage(AliQA::GetQARefStorage()) ;
 769                 else {
 770                         TString tmp(AliQA::GetQARefDefaultStorage()) ;
 771                         tmp.Append(year) ;
 772                         tmp.Append("?user=alidaq") ;
 773                         man->SetDefaultStorage(tmp.Data()) ;
 774                 }
 775         }
 776         man->SetSpecificStorage("*", AliQA::GetQARefStorage()) ;
 777         if(man->GetRun() < 0)
 778                 man->SetRun(runNumber);
 779
 780         AliCDBMetaData mdr ;
 781         mdr.SetResponsible("yves schutz");
 782
 783         for ( Int_t detIndex = 0 ; detIndex < AliQA::kNDET ; detIndex++) {
 784                 TDirectory * detDir = inputFile->GetDirectory(AliQA::GetDetName(detIndex)) ;
 785                 if ( detDir ) {
 786                         AliInfo(Form("Entering %s", detDir->GetName())) ;
 787                         TString detOCDBDir(Form("%s/%s/%s", AliQA::GetDetName(detIndex), AliQA::GetRefOCDBDirName(), AliQA::GetRefDataDirName())) ;
 788                         AliCDBId idr(detOCDBDir.Data(), runNumber, AliCDBRunRange::Infinity())  ;
 789                         TList * listDetQAD = new TList() ;
 790                         TString listName(Form("%s QA data Reference", AliQA::GetDetName(detIndex))) ;
 791                         mdr.SetComment("HMPID QA stuff");
 792                         listDetQAD->SetName(listName) ;
 793                         TList * taskList = detDir->GetListOfKeys() ;
 794                         TIter nextTask(taskList) ;
 795                         TKey * taskKey ;
 796                         while ( (taskKey = dynamic_cast<TKey*>(nextTask())) ) {
 797                                 TDirectory * taskDir = detDir->GetDirectory(taskKey->GetName()) ;
 798                                 AliInfo(Form("Saving %s", taskDir->GetName())) ;
 799                                 TObjArray * listTaskQAD = new TObjArray(100) ;
 800                                 listTaskQAD->SetName(taskKey->GetName()) ;
 801                                 listDetQAD->Add(listTaskQAD) ;
 802                                 TList * histList = taskDir->GetListOfKeys() ;
 803                                 TIter nextHist(histList) ;
 804                                 TKey * histKey ;
 805                                 while ( (histKey = dynamic_cast<TKey*>(nextHist())) ) {
 806                                         TObject * odata = taskDir->Get(histKey->GetName()) ;
 807                                         if ( !odata ) {
 808                                                 AliError(Form("%s in %s/%s returns a NULL pointer !!", histKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
 809                                         } else {
 810                                                 AliInfo(Form("Adding %s", histKey->GetName())) ;
 811                                                 if ( odata->IsA()->InheritsFrom("TH1") ) {
 812                                                         AliInfo(Form("Adding %s", histKey->GetName())) ;
 813                                                         TH1 * hdata = static_cast<TH1*>(odata) ;
 814                                                         listTaskQAD->Add(hdata) ;
 815                                                 }
 816                                         }
 817                                 }
 818                         }
 819                         man->Put(listDetQAD, idr, &mdr) ;
 820                 }
 821         }
 822         return rv ;
 823 }
 824