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