2b78a24cf07053c0851e0a1db5a0ebb8986f2797
[u/mrichter/AliRoot.git] / 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::Increment()
428 {
429   // Increments the cycle counter for all QA Data Makers
430         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
431                 if (IsSelected(AliQA::GetDetName(iDet))) {
432                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
433                         if (qadm) 
434         qadm->Increment() ;
435     }
436   }
437 }
438   
439 //_____________________________________________________________________________
440 Bool_t AliQADataMakerSteer::Init(const AliQA::TASKINDEX_t taskIndex, const  char * input )
441 {
442         // Initialize the event source and QA data makers
443         
444         //fTasks = AliQA::GetTaskName(taskIndex) ; 
445
446         if (taskIndex == AliQA::kRAWS) { 
447                 if (!fRawReader) {
448                         fRawReader = AliRawReader::Create(input);
449                 }
450                 if ( ! fRawReader ) 
451                         return kFALSE ; 
452                 fRawReaderDelete = kTRUE ; 
453                 fRawReader->NextEvent() ; 
454                 fRunNumber = fRawReader->GetRunNumber() ; 
455                 AliCDBManager::Instance()->SetRun(fRunNumber) ; 
456                 fRawReader->RewindEvents();
457                 fNumberOfEvents = 999999 ;
458                 if ( fMaxEvents < 0 ) 
459                         fMaxEvents = fNumberOfEvents ; 
460                 } else if (taskIndex == AliQA::kESDS) {
461                         fTasks = AliQA::GetTaskName(AliQA::kESDS) ; 
462                 if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
463                         TFile * esdFile = TFile::Open("AliESDs.root") ;
464                         fESDTree = dynamic_cast<TTree *> (esdFile->Get("esdTree")) ; 
465                         if ( !fESDTree ) {
466                                 AliError("esdTree not found") ; 
467                                 return kFALSE ; 
468                         } else {
469                                 fESD     = new AliESDEvent() ;
470                                 fESD->ReadFromTree(fESDTree) ;
471                                 fESDTree->GetEntry(0) ; 
472                                 fRunNumber = fESD->GetRunNumber() ; 
473                                 fNumberOfEvents = fESDTree->GetEntries() ;
474                                 if ( fMaxEvents < 0 ) 
475                                         fMaxEvents = fNumberOfEvents ; 
476                         }
477                 } else {
478                         AliError("AliESDs.root not found") ; 
479                         return kFALSE ; 
480                 }                       
481                 } else {
482                 if ( !InitRunLoader() ) { 
483                         AliWarning("No Run Loader not found") ; 
484                 } else {
485                         fNumberOfEvents = fRunLoader->GetNumberOfEvents() ;
486                         if ( fMaxEvents < 0 ) 
487                                 fMaxEvents = fNumberOfEvents ; 
488                 }
489         }
490
491         // Get Detectors 
492         TObjArray* detArray = NULL ; 
493         if (fRunLoader) // check if RunLoader exists 
494                 if ( fRunLoader->GetAliRun() ) { // check if AliRun exists in gAlice.root
495                         detArray = fRunLoader->GetAliRun()->Detectors() ;
496                         fRunNumber = fRunLoader->GetHeader()->GetRun() ; 
497                 }
498
499         // Initialize all QA data makers for all detectors
500         fRunNumber = AliCDBManager::Instance()->GetRun() ; 
501         if ( !  AliGeomManager::GetGeometry() ) 
502                 AliGeomManager::LoadGeometry() ; 
503         
504         InitQADataMaker(fRunNumber, fRecoParam, detArray) ; //, fCycleSame, kTRUE, detArray) ; 
505         return kTRUE ; 
506 }
507
508 //_____________________________________________________________________________
509 void  AliQADataMakerSteer::InitQADataMaker(UInt_t run, const AliRecoParam & par, TObjArray * detArray) 
510 {
511         // Initializes The QADataMaker for all active detectors and for all active tasks 
512
513         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
514                 if (IsSelected(AliQA::GetDetName(iDet))) {
515                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
516       if (fQAWriteExpert[iDet])
517         qadm->SetWriteExpert() ; 
518                         if (!qadm) {
519                                 AliError(Form("AliQADataMaker not found for %s", AliQA::GetDetName(iDet))) ; 
520                                 fDetectorsW.ReplaceAll(AliQA::GetDetName(iDet), "") ; 
521                         } else {
522                                 AliDebug(1, Form("Data Maker found for %s", qadm->GetName())) ; 
523                                 // skip non active detectors
524                                 if (detArray) {
525                                         AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQA::GetDetName(iDet))) ;
526                                         if (!det || !det->IsActive())  
527                                                 continue ;
528                                 }
529               // Set default reco params
530                                 qadm->SetRecoParam(par.GetDetRecoParam(iDet));
531         Bool_t sameCycle = kFALSE ; 
532                                 for (UInt_t taskIndex = 0; taskIndex < AliQA::kNTASKINDEX; taskIndex++) {
533                                         if ( fTasks.Contains(Form("%d", taskIndex)) ) {
534             qadm->StartOfCycle(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex)), run,  sameCycle) ;
535                                                 qadm->Init(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex)), GetQACycles(qadm->GetUniqueID())) ;
536             sameCycle = kTRUE ;
537                                         }
538                                 }
539                         }
540                 }
541         }
542 }
543
544
545 //_____________________________________________________________________________
546 Bool_t AliQADataMakerSteer::InitRunLoader()
547 {
548         // get or create the run loader
549         if (fRunLoader) {
550                 fCycleSame = kTRUE ; 
551         } else {
552                 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
553                         // load all base libraries to get the loader classes
554                         TString libs = gSystem->GetLibraries() ;
555                         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
556                                 if (!IsSelected(AliQA::GetDetName(iDet))) 
557                                         continue ; 
558                                 TString detName = AliQA::GetDetName(iDet) ;
559                                 if (detName == "HLT") 
560                                         continue;
561                                 if (libs.Contains("lib" + detName + "base.so")) 
562                                         continue;
563                                 gSystem->Load("lib" + detName + "base.so");
564                         }
565                         fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
566                         if (!fRunLoader) {
567                                 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
568                                 return kFALSE;
569                         }
570                         fRunLoader->CdGAFile();
571                         if (fRunLoader->LoadgAlice() == 0) {
572                                 gAlice = fRunLoader->GetAliRun();
573                         }
574
575                         if (!gAlice) {
576                                 AliError(Form("no gAlice object found in file %s", fGAliceFileName.Data()));
577                                 return kFALSE;
578                         }
579
580                 } else {               // galice.root does not exist
581                         AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
582                         return kFALSE;
583                 }
584         }
585
586         if (!fRunNumber) { 
587                 fRunLoader->LoadHeader();
588                 fRunNumber = fRunLoader->GetHeader()->GetRun() ; 
589         }
590         return kTRUE;
591 }
592
593 //_____________________________________________________________________________
594 Bool_t AliQADataMakerSteer::IsSelected(const char * det) 
595 {
596         // check whether detName is contained in detectors
597         // if yes, it is removed from detectors
598         
599         Bool_t rv = kFALSE;
600         const TString detName(det) ;
601   // always activates Correlation
602   if ( detName.Contains(AliQA::GetDetName(AliQA::kCORR))) {
603     rv = kTRUE ; 
604   } else {
605     // check if all detectors are selected
606     if (fDetectors.Contains("ALL")) {
607       fDetectors = "ALL";
608       rv = kTRUE;
609     } else if ((fDetectors.CompareTo(detName) == 0) ||
610                fDetectors.BeginsWith(detName+" ") ||
611                fDetectors.EndsWith(" "+detName) ||
612                fDetectors.Contains(" "+detName+" ")) {
613       rv = kTRUE;
614     }
615   }
616         return rv ;
617 }
618
619 //_____________________________________________________________________________
620 Bool_t AliQADataMakerSteer::Merge(const Int_t runNumber) const
621 {
622         // Merge data from all the cycles from all detectors in one single file per run
623         // Merge the QA results from all the data chunks in one run 
624  Bool_t rv = MergeData(runNumber) ; 
625  rv *= MergeResults(runNumber) ;
626  return rv ; 
627 }
628         
629         
630 //_____________________________________________________________________________
631 Bool_t AliQADataMakerSteer::MergeData(const Int_t runNumber) const
632 {
633         // Merge all the cycles from all detectors in one single file per run
634         TString cmd ;
635         if (runNumber == -1) 
636                 cmd = Form(".! ls *%s*.%d.root > tempo.txt", AliQA::GetQADataFileName(), runNumber) ; 
637         else 
638                 cmd = Form(".! ls *%s*.*.root > tempo.txt", AliQA::GetQADataFileName()) ; 
639         gROOT->ProcessLine(cmd.Data()) ;
640         ifstream in("tempo.txt") ; 
641         const Int_t runMax = 10 ;  
642         TString file[AliQA::kNDET*runMax] ;
643         
644         Int_t index = 0 ; 
645         while ( 1 ) {
646                 in >> file[index] ; 
647                 if ( !in.good() ) 
648                         break ; 
649                 AliInfo(Form("index = %d file = %s", index, (file[index]).Data())) ; 
650                 index++ ;
651         }
652         
653         if ( index == 0 ) { 
654                 AliError(Form("run number %d not found", runNumber)) ; 
655                 return kFALSE ; 
656         }
657
658   TFileMerger merger ; 
659   TString outFileName(Form("Merged.%s.Data.%d.root",AliQA::GetQADataFileName(),runNumber)); 
660   merger.OutputFile(outFileName.Data()) ; 
661   for (Int_t ifile = 0 ; ifile < index-1 ; ifile++) {
662     TString pattern(Form("%s.%d.", AliQA::GetQADataFileName(), runNumber)); 
663     TString tmp(file[ifile]) ; 
664     if (tmp.Contains(pattern)) {
665       merger.AddFile(tmp) ; 
666     }
667         }
668   merger.Merge() ; 
669         return kTRUE ; 
670 }
671
672 //_____________________________________________________________________________
673 Bool_t AliQADataMakerSteer::MergeResults(const Int_t runNumber) const
674 {
675         // Merge the QA result from all the data chunks in a run 
676         TString cmd ;
677         cmd = Form(".! ls %s*.root > tempo.txt", AliQA::GetQADataFileName()) ; 
678         gROOT->ProcessLine(cmd.Data()) ;
679         ifstream in("tempo.txt") ; 
680         const Int_t chunkMax = 100 ;  
681         TString fileList[chunkMax] ;
682         
683         Int_t index = 0 ; 
684         while ( 1 ) {
685                 TString file ; 
686                 in >> fileList[index] ; 
687                 if ( !in.good() ) 
688                         break ; 
689                 AliInfo(Form("index = %d file = %s", index, (fileList[index].Data()))) ; 
690                 index++ ;
691         }
692         
693         if ( index == 0 ) { 
694                 AliError("No QA Result File found") ; 
695                 return kFALSE ; 
696         }
697         
698         TFileMerger merger ; 
699         TString outFileName(Form("Merged.%s.Result.%d.root", AliQA::GetQADataFileName(), runNumber));           
700         merger.OutputFile(outFileName.Data()) ; 
701         for (Int_t ifile = 0 ; ifile < index ; ifile++) {
702                 TString file = fileList[ifile] ; 
703                 merger.AddFile(file) ; 
704         }
705         merger.Merge() ; 
706         
707         return kTRUE ; 
708 }
709
710 //_____________________________________________________________________________
711 void AliQADataMakerSteer::Reset(const Bool_t sameCycle)
712 {
713         // Reset the default data members
714
715         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
716                 if (IsSelected(AliQA::GetDetName(iDet))) {
717                         AliQADataMaker * qadm = GetQADataMaker(iDet);
718                         qadm->Reset();
719                 }
720         } 
721         if (fRawReaderDelete) { 
722                 delete fRawReader ;
723                 fRawReader      = NULL ;
724         }
725
726         fCycleSame      = sameCycle ; 
727         fESD            = NULL ; 
728         fESDTree        = NULL ; 
729         //fFirst          = kTRUE ;   
730         fNumberOfEvents = 999999 ;  
731 }
732
733 //_____________________________________________________________________________
734 TString AliQADataMakerSteer::Run(const char * detectors, AliRawReader * rawReader, const Bool_t sameCycle) 
735 {
736         //Runs all the QA data Maker for Raws only
737         
738         fCycleSame       = sameCycle ;
739         fRawReader       = rawReader ;
740         fDetectors       = detectors ; 
741         fDetectorsW      = detectors ;  
742         
743         AliCDBManager* man = AliCDBManager::Instance() ; 
744
745         if ( man->GetRun() == -1 ) {// check if run number not set previously and set it from raw data
746                 rawReader->NextEvent() ; 
747                 man->SetRun(fRawReader->GetRunNumber()) ;
748                 rawReader->RewindEvents() ;
749         }       
750         
751         if ( !Init(AliQA::kRAWS) ) 
752                 return kFALSE ; 
753         fRawReaderDelete = kFALSE ; 
754
755         DoIt(AliQA::kRAWS) ; 
756         return  fDetectorsW ;
757 }
758
759 //_____________________________________________________________________________
760 TString AliQADataMakerSteer::Run(const char * detectors, const char * fileName, const Bool_t sameCycle) 
761 {
762         //Runs all the QA data Maker for Raws only
763
764         fCycleSame       = sameCycle ;
765         fDetectors       = detectors ; 
766         fDetectorsW      = detectors ;  
767         
768         AliCDBManager* man = AliCDBManager::Instance() ; 
769         if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
770                 AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
771                 if ( ! rl ) {
772                         AliFatal("galice.root file not found in current directory") ; 
773                 } else {
774                         rl->CdGAFile() ; 
775                         rl->LoadgAlice() ;
776                         if ( ! rl->GetAliRun() ) {
777                                 AliFatal("AliRun not found in galice.root") ;
778                         } else {
779                                 rl->LoadHeader() ;
780                                 man->SetRun(rl->GetHeader()->GetRun());
781                         }
782                 }
783         }
784         
785         if ( !Init(AliQA::kRAWS, fileName) ) 
786                 return kFALSE ; 
787         
788         DoIt(AliQA::kRAWS) ; 
789         return  fDetectorsW ;
790 }
791
792 //_____________________________________________________________________________
793 TString AliQADataMakerSteer::Run(const char * detectors, const AliQA::TASKINDEX_t taskIndex, Bool_t const sameCycle, const  char * fileName ) 
794 {
795         // Runs all the QA data Maker for every detector
796         
797         fCycleSame       = sameCycle ;
798         fDetectors       = detectors ; 
799         fDetectorsW      = detectors ;          
800         
801         AliCDBManager* man = AliCDBManager::Instance() ;        
802         if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
803                 AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
804                 if ( ! rl ) {
805                         AliFatal("galice.root file not found in current directory") ; 
806                 } else {
807                         rl->CdGAFile() ; 
808                         rl->LoadgAlice() ;
809                         if ( ! rl->GetAliRun() ) {
810                                 AliInfo("AliRun not found in galice.root") ;
811                         } else {
812                                 rl->LoadHeader() ;
813                                 man->SetRun(rl->GetHeader()->GetRun()) ;
814                         }
815                 }
816         }
817         
818
819         if ( taskIndex == AliQA::kNULLTASKINDEX) { 
820                 for (UInt_t task = 0; task < AliQA::kNTASKINDEX; task++) {
821                         if ( fTasks.Contains(Form("%d", task)) ) {
822                                 if ( !Init(AliQA::GetTaskIndex(AliQA::GetTaskName(task)), fileName) ) 
823                                         return kFALSE ; 
824                                 DoIt(AliQA::GetTaskIndex(AliQA::GetTaskName(task))) ;
825                         }
826                 }
827         } else {
828                 if ( !Init(taskIndex, fileName) ) 
829                         return kFALSE ; 
830                 DoIt(taskIndex) ; 
831         }               
832         
833         return fDetectorsW ;
834
835 }
836
837 //_____________________________________________________________________________
838 void AliQADataMakerSteer::RunOneEvent(AliRawReader * rawReader) 
839 {
840         //Runs all the QA data Maker for Raws only and on one event only (event loop done by calling method)
841   if ( ! rawReader ) 
842     return ; 
843         AliCodeTimerAuto("") ;
844   if (fTasks.Contains(Form("%d", AliQA::kRAWS))){
845     for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
846       if (!IsSelected(AliQA::GetDetName(iDet))) 
847         continue;
848       AliQADataMaker *qadm = GetQADataMaker(iDet);  
849       if (!qadm) 
850         continue;
851       if ( qadm->IsCycleDone() ) {
852         qadm->EndOfCycle() ;
853       }
854       AliCodeTimerStart(Form("running RAW quality assurance data maker for %s", AliQA::GetDetName(iDet))); 
855                         qadm->Exec(AliQA::kRAWS, rawReader) ;
856       AliCodeTimerStop(Form("running RAW quality assurance data maker for %s", AliQA::GetDetName(iDet)));
857                 }
858   }
859 }
860
861 //_____________________________________________________________________________
862 void AliQADataMakerSteer::RunOneEvent(AliESDEvent *& esd) 
863 {
864         //Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
865         
866   AliCodeTimerAuto("") ;
867   if (fTasks.Contains(Form("%d", AliQA::kESDS))) {
868     for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
869       if (!IsSelected(AliQA::GetDetName(iDet))) 
870         continue;
871       AliQADataMaker *qadm = GetQADataMaker(iDet);  
872       if (!qadm) 
873         continue;
874       if ( qadm->IsCycleDone() ) {
875         qadm->EndOfCycle() ;
876       }
877       AliCodeTimerStart(Form("running ESD quality assurance data maker for %s", AliQA::GetDetName(iDet)));
878                         qadm->Exec(AliQA::kESDS, esd) ;
879       AliCodeTimerStop(Form("running ESD quality assurance data maker for %s", AliQA::GetDetName(iDet)));
880                 }
881         }
882 }
883
884 //_____________________________________________________________________________
885 void AliQADataMakerSteer::RunOneEventInOneDetector(Int_t det, TTree * tree) 
886 {
887         // Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
888         AliCodeTimerAuto("") ;
889   if (fTasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
890     if (IsSelected(AliQA::GetDetName(det))) {
891       AliQADataMaker *qadm = GetQADataMaker(det);  
892       if (qadm) { 
893         if ( qadm->IsCycleDone() ) {
894           qadm->EndOfCycle() ;
895         }
896         AliCodeTimerStart(Form("running RecPoints quality assurance data maker for %s", AliQA::GetDetName(det)));
897         qadm->Exec(AliQA::kRECPOINTS, tree) ;
898         AliCodeTimerStop(Form("running RecPoints quality assurance data maker for %s", AliQA::GetDetName(det)));
899       }
900     }
901   }
902 }
903
904 //_____________________________________________________________________________
905 Bool_t AliQADataMakerSteer::Save2OCDB(const Int_t runNumber, const char * year, const char * detectors) const
906 {
907         // take the locasl QA data merge into a single file and save in OCDB 
908         Bool_t rv = kTRUE ; 
909         TString tmp(AliQA::GetQARefStorage()) ; 
910         if ( tmp.IsNull() ) { 
911                 AliError("No storage defined, use AliQA::SetQARefStorage") ; 
912                 return kFALSE ; 
913         }
914         if ( !(tmp.Contains(AliQA::GetLabLocalOCDB()) || tmp.Contains(AliQA::GetLabAliEnOCDB())) ) {
915                 AliError(Form("%s is a wrong storage, use %s or %s", AliQA::GetQARefStorage(), AliQA::GetLabLocalOCDB().Data(), AliQA::GetLabAliEnOCDB().Data())) ; 
916                 return kFALSE ; 
917         }
918         TString sdet(detectors) ; 
919         sdet.ToUpper() ;
920         TFile * inputFile ; 
921         if ( sdet.Contains("ALL") ) {
922                 rv = Merge(runNumber) ; 
923                 if ( ! rv )
924                         return kFALSE ; 
925                 TString inputFileName(Form("Merged.%s.Data.%d.root", AliQA::GetQADataFileName(), runNumber)) ; 
926                 inputFile = TFile::Open(inputFileName.Data()) ; 
927                 rv = SaveIt2OCDB(runNumber, inputFile, year) ; 
928         } else {
929                 for (Int_t index = 0; index < AliQA::kNDET; index++) {
930                         if (sdet.Contains(AliQA::GetDetName(index))) {
931                                 TString inputFileName(Form("%s.%s.%d.root", AliQA::GetDetName(index), AliQA::GetQADataFileName(), runNumber)) ; 
932                                 inputFile = TFile::Open(inputFileName.Data()) ;                         
933                                 rv *= SaveIt2OCDB(runNumber, inputFile, year) ; 
934                         }
935                 }
936         }
937         return rv ; 
938 }
939
940 //_____________________________________________________________________________
941 Bool_t AliQADataMakerSteer::SaveIt2OCDB(const Int_t runNumber, TFile * inputFile, const char * year) const
942 {
943         // reads the TH1 from file and adds it to appropriate list before saving to OCDB
944         Bool_t rv = kTRUE ;
945         AliInfo(Form("Saving TH1s in %s to %s", inputFile->GetName(), AliQA::GetQARefStorage())) ; 
946         AliCDBManager* man = AliCDBManager::Instance() ; 
947         if ( ! man->IsDefaultStorageSet() ) {
948                 TString tmp( AliQA::GetQARefStorage() ) ; 
949                 if ( tmp.Contains(AliQA::GetLabLocalOCDB()) ) 
950                         man->SetDefaultStorage(AliQA::GetQARefStorage()) ;
951                 else {
952                         TString tmp1(AliQA::GetQARefDefaultStorage()) ; 
953                         tmp1.Append(year) ; 
954                         tmp1.Append("?user=alidaq") ; 
955                         man->SetDefaultStorage(tmp1.Data()) ; 
956                 }
957         }
958         man->SetSpecificStorage("*", AliQA::GetQARefStorage()) ; 
959         if(man->GetRun() < 0) 
960                 man->SetRun(runNumber);
961
962         AliCDBMetaData mdr ;
963         mdr.SetResponsible("yves schutz");
964
965         for ( Int_t detIndex = 0 ; detIndex < AliQA::kNDET ; detIndex++) {
966                 TDirectory * detDir = inputFile->GetDirectory(AliQA::GetDetName(detIndex)) ; 
967                 if ( detDir ) {
968                         AliInfo(Form("Entering %s", detDir->GetName())) ;
969                         TString detOCDBDir(Form("%s/%s/%s", AliQA::GetDetName(detIndex), AliQA::GetRefOCDBDirName(), AliQA::GetRefDataDirName())) ; 
970       printf("SSSSSSSSSSSSSSSSSSSSS %s\n", detOCDBDir.Data()) ; 
971                         AliCDBId idr(detOCDBDir.Data(), runNumber, AliCDBRunRange::Infinity())  ;
972                         TList * listDetQAD = new TList() ;
973                         TString listName(Form("%s QA data Reference", AliQA::GetDetName(detIndex))) ; 
974                         mdr.SetComment("HMPID QA stuff");
975                         listDetQAD->SetName(listName) ; 
976                         TList * taskList = detDir->GetListOfKeys() ; 
977                         TIter nextTask(taskList) ; 
978                         TKey * taskKey ; 
979                         while ( (taskKey = dynamic_cast<TKey*>(nextTask())) ) {
980                                 TDirectory * taskDir = detDir->GetDirectory(taskKey->GetName()) ; 
981                                 AliInfo(Form("Saving %s", taskDir->GetName())) ; 
982                                 TObjArray * listTaskQAD = new TObjArray(100) ; 
983                                 listTaskQAD->SetName(taskKey->GetName()) ;
984                                 listDetQAD->Add(listTaskQAD) ; 
985                                 TList * histList = taskDir->GetListOfKeys() ; 
986                                 TIter nextHist(histList) ; 
987                                 TKey * histKey ; 
988                                 while ( (histKey = dynamic_cast<TKey*>(nextHist())) ) {
989                                         TObject * odata = taskDir->Get(histKey->GetName()) ; 
990                                         if ( !odata ) {
991                                                 AliError(Form("%s in %s/%s returns a NULL pointer !!", histKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
992                                         } else {
993                                                 AliInfo(Form("Adding %s", histKey->GetName())) ;
994                                                 if ( odata->IsA()->InheritsFrom("TH1") ) {
995                                                         AliInfo(Form("Adding %s", histKey->GetName())) ;
996                                                         TH1 * hdata = static_cast<TH1*>(odata) ; 
997                                                         listTaskQAD->Add(hdata) ; 
998                                                 }
999                                         }
1000                                 }
1001                         }
1002                         man->Put(listDetQAD, idr, &mdr) ;
1003                 }
1004         }
1005         return rv ; 
1006 }       
1007
1008 //_____________________________________________________________________________
1009 void AliQADataMakerSteer::SetRecoParam(const char* detector, AliDetectorRecoParam *par)
1010 {
1011   // Set custom reconstruction parameters for a given detector
1012   // Single set of parameters for all the events
1013   for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1014     if(!strcmp(detector, AliQA::GetDetName(iDet))) {
1015       par->SetAsDefault();
1016       fRecoParam.AddDetRecoParam(iDet,par);
1017       break;
1018     }
1019   }
1020 }
1021
1022