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