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