Corrected protection.
[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(AliQAv1::kRAWS, rawROOTFileName);                               //
23 //   qas.Run(AliQAv1::kHITS);                                                //
24 //   qas.Run(AliQAv1::kSDIGITS);                                             //
25 //   qas.Run(AliQAv1::kDIGITS);                                              //
26 //   qas.Run(AliQAv1::kRECPOINTS);                                           //
27 //   qas.Run(AliQAv1::kESDS);                                                //
28 //                                                                           //
29 ///////////////////////////////////////////////////////////////////////////////
30
31 #include <TCanvas.h>
32 #include <TKey.h>
33 #include <TFile.h>
34 #include <TFileMerger.h>
35 #include <TGrid.h>
36 #include <TGridCollection.h>
37 #include <TGridResult.h>
38 #include <TPluginManager.h>
39 #include <TROOT.h>
40 #include <TString.h>
41 #include <TSystem.h>
42 #include <TStopwatch.h>
43
44 #include "AliCDBManager.h"
45 #include "AliCDBEntry.h"
46 #include "AliCDBId.h"
47 #include "AliCDBMetaData.h"
48 #include "AliCodeTimer.h"
49 #include "AliCorrQADataMakerRec.h"
50 #include "AliDetectorRecoParam.h"
51 #include "AliESDEvent.h"
52 #include "AliGeomManager.h"
53 #include "AliGlobalQADataMaker.h"
54 #include "AliHeader.h"
55 #include "AliLog.h"
56 #include "AliModule.h"
57 #include "AliQAv1.h"
58 #include "AliQAChecker.h"
59 #include "AliQACheckerBase.h"
60 #include "AliQADataMakerRec.h"
61 #include "AliQADataMakerSim.h"
62 #include "AliQAManager.h" 
63 #include "AliRawReaderDate.h"
64 #include "AliRawReaderFile.h"
65 #include "AliRawReaderRoot.h"
66 #include "AliRun.h"
67 #include "AliRunLoader.h"
68 #include "AliRunTag.h"
69
70 ClassImp(AliQAManager) 
71 AliQAManager* AliQAManager::fgQAInstance = 0x0;
72
73 //_____________________________________________________________________________
74 AliQAManager::AliQAManager() :
75   AliCDBManager(), 
76   fCurrentEvent(0),   
77   fCycleSame(kFALSE),
78   fDetectors("ALL"), 
79   fDetectorsW("ALL"), 
80   fESD(NULL), 
81   fESDTree(NULL),
82   fGAliceFileName(""), 
83   fFirstEvent(0),        
84   fMaxEvents(0),   
85   fMode(""), 
86   fNumberOfEvents(999999), 
87   fRecoParam(),
88   fRunNumber(0), 
89   fRawReader(NULL), 
90   fRawReaderDelete(kTRUE), 
91   fRunLoader(NULL), 
92   fTasks(""),  
93   fEventSpecie(AliRecoParam::kDefault), 
94   fPrintImage(kTRUE), 
95   fSaveData(kTRUE) 
96 {
97         // default ctor
98         fMaxEvents = fNumberOfEvents ; 
99         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
100                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
101                         fLoader[iDet]      = NULL ;
102                         fQADataMaker[iDet] = NULL ;
103                         fQACycles[iDet]    = 999999 ;
104                 }
105         }       
106   SetWriteExpert() ; 
107 }
108
109 //_____________________________________________________________________________
110 AliQAManager::AliQAManager(AliQAv1::MODE_t mode, const Char_t* gAliceFilename) :
111   AliCDBManager(), 
112   fCurrentEvent(0),  
113         fCycleSame(kFALSE),
114         fDetectors("ALL"), 
115         fDetectorsW("ALL"), 
116         fESD(NULL), 
117         fESDTree(NULL),
118         fGAliceFileName(gAliceFilename), 
119         fFirstEvent(0),        
120         fMaxEvents(0),   
121   fMode(AliQAv1::GetModeName(mode)), 
122         fNumberOfEvents(999999), 
123   fRecoParam(),
124         fRunNumber(0), 
125         fRawReader(NULL), 
126         fRawReaderDelete(kTRUE), 
127         fRunLoader(NULL), 
128   fTasks(""), 
129   fEventSpecie(AliRecoParam::kDefault), 
130   fPrintImage(kTRUE), 
131   fSaveData(kTRUE) 
132 {
133         // default ctor
134         fMaxEvents = fNumberOfEvents ; 
135         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
136                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
137                         fLoader[iDet]      = NULL ;
138                         fQADataMaker[iDet] = NULL ;
139                         fQACycles[iDet]    = 999999 ;
140     }
141   }
142   SetWriteExpert() ; 
143 }
144
145 //_____________________________________________________________________________
146 AliQAManager::AliQAManager(const AliQAManager & qas) : 
147   AliCDBManager(), 
148         fCurrentEvent(qas.fCurrentEvent),  
149         fCycleSame(kFALSE),
150         fDetectors(qas.fDetectors), 
151         fDetectorsW(qas.fDetectorsW), 
152         fESD(NULL), 
153         fESDTree(NULL), 
154         fGAliceFileName(qas.fGAliceFileName), 
155         fFirstEvent(qas.fFirstEvent),        
156         fMaxEvents(qas.fMaxEvents),    
157         fMode(qas.fMode), 
158         fNumberOfEvents(qas.fNumberOfEvents), 
159         fRecoParam(),           
160         fRunNumber(qas.fRunNumber), 
161         fRawReader(NULL), 
162         fRawReaderDelete(kTRUE), 
163         fRunLoader(NULL), 
164   fTasks(qas.fTasks), 
165   fEventSpecie(qas.fEventSpecie), 
166   fPrintImage(qas.fPrintImage), 
167   fSaveData(qas.fSaveData) 
168
169 {
170         // cpy ctor
171         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
172                 fLoader[iDet]         = qas.fLoader[iDet] ;
173                 fQADataMaker[iDet]    = qas.fQADataMaker[iDet] ;
174                 fQACycles[iDet]       = qas.fQACycles[iDet] ;   
175     fQAWriteExpert[iDet] = qas.fQAWriteExpert[iDet] ;
176   }
177 }
178
179 //_____________________________________________________________________________
180 AliQAManager & AliQAManager::operator = (const AliQAManager & qas) 
181 {
182         // assignment operator
183   this->~AliQAManager() ;
184   new(this) AliQAManager(qas) ;
185   return *this ;
186 }
187
188 //_____________________________________________________________________________
189 AliQAManager::~AliQAManager() 
190 {
191         // dtor
192         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
193                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
194                   fLoader[iDet] = NULL;
195                   if (fQADataMaker[iDet]) {
196                           (fQADataMaker[iDet])->Finish() ; 
197                                 delete fQADataMaker[iDet] ;
198                   }
199                 }
200         }
201         if (fRawReaderDelete) { 
202                 fRunLoader = NULL ;
203                 delete fRawReader ;
204                 fRawReader = NULL ;
205         }
206 }
207 //_____________________________________________________________________________
208 Bool_t AliQAManager::DoIt(const AliQAv1::TASKINDEX_t taskIndex)
209 {
210         // Runs all the QA data Maker for every detector
211                 
212         Bool_t rv = kFALSE ;
213     // Fill QA data in event loop 
214         for (UInt_t iEvent = fFirstEvent ; iEvent < (UInt_t)fMaxEvents ; iEvent++) {
215                 fCurrentEvent++ ; 
216                 // Get the event
217                 if ( iEvent%10 == 0  ) 
218                         AliDebug(AliQAv1::GetQADebugLevel(), Form("processing event %d", iEvent));
219                 if ( taskIndex == AliQAv1::kRAWS ) {
220                         if ( !fRawReader->NextEvent() )
221                                 break ;
222                 } else if ( taskIndex == AliQAv1::kESDS ) {
223                         if ( fESDTree->GetEntry(iEvent) == 0 )
224                                 break ;
225                 } else {
226                         if ( fRunLoader->GetEvent(iEvent) != 0 )
227                                 break ;
228                 }
229                 // loop  over active loaders
230                 for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
231                         if (IsSelected(AliQAv1::GetDetName(iDet))) {
232                                 AliQADataMaker * qadm = GetQADataMaker(iDet) ;
233                                 if (!qadm) continue; // This detector doesn't have any QA (for example, HLT)
234                                 if ( qadm->IsCycleDone() ) {
235           qadm->EndOfCycle(taskIndex) ;
236                                 }
237                                 TTree * data = NULL ; 
238                                 AliLoader* loader = GetLoader(qadm->GetUniqueID());
239                                 switch (taskIndex) {
240                                         case AliQAv1::kNULLTASKINDEX : 
241                                                 break ; 
242                                         case AliQAv1::kRAWS :
243                                                 qadm->Exec(taskIndex, fRawReader) ; 
244                                                 break ; 
245                                         case AliQAv1::kHITS :
246             if( loader ) {
247               loader->LoadHits() ; 
248               data = loader->TreeH() ; 
249               if ( ! data ) {
250                 AliWarning(Form(" Hit Tree not found for  %s", AliQAv1::GetDetName(iDet))) ; 
251                 break ; 
252               } 
253               qadm->Exec(taskIndex, data) ;
254             } 
255                                                 break ;
256                                                 case AliQAv1::kSDIGITS :
257           {
258             
259             TString fileName(Form("%s.SDigits.root", AliQAv1::GetDetName(iDet))) ; 
260             if (gSystem->FindFile("./", fileName)) {
261               if( loader ) {      
262                 loader->LoadSDigits() ; 
263                 data = loader->TreeS() ; 
264                 if ( ! data ) {
265                   AliWarning(Form(" SDigit Tree not found for  %s", AliQAv1::GetDetName(iDet))) ; 
266                   break ; 
267                 } 
268                 qadm->Exec(taskIndex, data) ; 
269               }
270             }
271           }
272                                                 break; 
273                                                 case AliQAv1::kDIGITS :
274               if( loader ) {      
275                 loader->LoadDigits() ; 
276                 data = loader->TreeD() ; 
277                 if ( ! data ) {
278                   AliWarning(Form(" Digit Tree not found for  %s", AliQAv1::GetDetName(iDet))) ; 
279                   break ; 
280                 } 
281                 qadm->Exec(taskIndex, data) ;
282               }
283             break;
284             case AliQAv1::kDIGITSR :
285               if( loader ) {      
286                 loader->LoadDigits() ; 
287                 data = loader->TreeD() ; 
288                 if ( ! data ) {
289                   AliWarning(Form(" Digit Tree not found for  %s", AliQAv1::GetDetName(iDet))) ; 
290                   break ; 
291                 } 
292                 qadm->Exec(taskIndex, data) ;
293               }
294                                                 break; 
295                                                 case AliQAv1::kRECPOINTS :
296             if( loader ) {      
297               loader->LoadRecPoints() ; 
298               data = loader->TreeR() ; 
299               if (!data) {
300                 AliWarning(Form("RecPoints not found for %s", AliQAv1::GetDetName(iDet))) ; 
301                 break ; 
302               } 
303               qadm->Exec(taskIndex, data) ; 
304             }
305             break; 
306                                                 case AliQAv1::kTRACKSEGMENTS :
307                                                 break; 
308                                                 case AliQAv1::kRECPARTICLES :
309                                                 break; 
310                                                 case AliQAv1::kESDS :
311                                                 qadm->Exec(taskIndex, fESD) ;
312                                                 break; 
313                                                 case AliQAv1::kNTASKINDEX :
314                                                 break; 
315                                 } //task switch
316                         }
317                 } // detector loop
318     Increment(taskIndex) ; 
319         } // event loop 
320         // Save QA data for all detectors
321
322   EndOfCycle() ; 
323         
324         if ( taskIndex == AliQAv1::kRAWS ) 
325                 fRawReader->RewindEvents() ;
326
327         return rv ; 
328 }
329
330 //_____________________________________________________________________________
331 Bool_t AliQAManager::Finish(const AliQAv1::TASKINDEX_t taskIndex) 
332 {
333         // write output to file for all detectors
334   
335   AliQAChecker::Instance()->SetRunNumber(fRunNumber) ; 
336
337         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
338                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
339                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
340                         if (qadm) 
341         qadm->EndOfCycle(taskIndex) ;
342                 }
343         }
344         return kTRUE ; 
345 }
346
347 //_____________________________________________________________________________
348 TObjArray * AliQAManager::GetFromOCDB(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, const Char_t * year) const 
349 {
350         // Retrieve the list of QA data for a given detector and a given task 
351         TObjArray * rv = NULL ;
352         if ( !strlen(AliQAv1::GetQARefStorage()) ) { 
353                 AliError("No storage defined, use AliQAv1::SetQARefStorage") ; 
354                 return NULL ; 
355         }       
356         if ( ! IsDefaultStorageSet() ) {
357                 TString tmp(AliQAv1::GetQARefDefaultStorage()) ; 
358                 tmp.Append(year) ; 
359                 tmp.Append("/") ; 
360                 Instance()->SetDefaultStorage(tmp.Data()) ;             
361                 Instance()->SetSpecificStorage(Form("%s/*", AliQAv1::GetQAName()), AliQAv1::GetQARefStorage()) ;
362         }
363         TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetQAName(), AliQAv1::GetDetName((Int_t)det), AliQAv1::GetRefOCDBDirName())) ; 
364      AliDebug(AliQAv1::GetQADebugLevel(), Form("Retrieving reference data from %s/%s for %s", AliQAv1::GetQARefStorage(), detOCDBDir.Data(), AliQAv1::GetTaskName(task).Data())) ; 
365         AliCDBEntry* entry = QAManager()->Get(detOCDBDir.Data(), 0) ; //FIXME 0 --> Run Number
366         TList * listDetQAD = static_cast<TList *>(entry->GetObject()) ;
367         if ( listDetQAD ) 
368                 rv = static_cast<TObjArray *>(listDetQAD->FindObject(AliQAv1::GetTaskName(task))) ; 
369         return rv ; 
370 }
371
372 //_____________________________________________________________________________
373 TCanvas ** AliQAManager::GetImage(Char_t * detName)
374 {
375   // retrieves QA Image for the given detector
376   TCanvas ** rv = NULL ; 
377   Int_t detIndex = AliQAv1::GetDetIndex(detName) ; 
378   AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(detIndex) ; 
379   rv = qac->GetImage() ;
380   return rv ; 
381 }
382
383 //_____________________________________________________________________________
384 AliLoader * AliQAManager::GetLoader(Int_t iDet)
385 {
386         // get the loader for a detector
387
388         if ( !fRunLoader || iDet == AliQAv1::kCORR || iDet == AliQAv1::kGLOBAL ) 
389                 return NULL ; 
390         
391         TString detName = AliQAv1::GetDetName(iDet) ;
392     fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
393         if (fLoader[iDet]) 
394                 return fLoader[iDet] ;
395         
396         // load the QA data maker object
397         TPluginManager* pluginManager = gROOT->GetPluginManager() ;
398         TString loaderName = "Ali" + detName + "Loader" ;
399
400         AliLoader * loader = NULL ;
401         // first check if a plugin is defined for the quality assurance data maker
402         TPluginHandler* pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
403         // if not, add a plugin for it
404         if (!pluginHandler) {
405                 AliDebug(AliQAv1::GetQADebugLevel(), Form("defining plugin for %s", loaderName.Data())) ;
406                 TString libs = gSystem->GetLibraries() ;
407                 if (libs.Contains("lib" + detName + "base.so") || (gSystem->Load("lib" + detName + "base.so") >= 0)) {
408                         pluginManager->AddHandler("AliQADataMaker", detName, loaderName, detName + "loader", loaderName + "()") ;
409                 } else {
410                         pluginManager->AddHandler("AliLoader", detName, loaderName, detName, loaderName + "()") ;
411                 }
412                 pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
413         }
414         if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
415                 loader = (AliLoader *) pluginHandler->ExecPlugin(0) ;
416         }
417         if (loader) 
418                 fLoader[iDet] = loader ;
419         return loader ;
420 }
421
422 //_____________________________________________________________________________
423 AliQAv1 * AliQAManager::GetQA(UInt_t run, UInt_t evt) 
424 {
425 // retrieves the QA object stored in a file named "Run{run}.Event{evt}_1.ESD.tag.root"  
426   Char_t * fileName = Form("Run%d.Event%d_1.ESD.tag.root", run, evt) ; 
427   TFile * tagFile = TFile::Open(fileName) ;
428   if ( !tagFile ) {
429     AliError(Form("File %s not found", fileName)) ;
430     return NULL ; 
431   }
432   TTree * tagTree = static_cast<TTree *>(tagFile->Get("T")) ; 
433   if ( !tagTree ) {
434     AliError(Form("Tree T not found in %s", fileName)) ; 
435     tagFile->Close() ; 
436     return NULL ; 
437   }
438   AliRunTag * tag = new AliRunTag ; 
439   tagTree->SetBranchAddress("AliTAG", &tag) ; 
440   tagTree->GetEntry(evt) ; 
441   AliQAv1 * qa = AliQAv1::Instance(tag->GetQALength(), tag->GetQAArray(), tag->GetESLength(), tag->GetEventSpecies()) ; 
442   tagFile->Close() ; 
443   return qa ; 
444 }
445
446 //_____________________________________________________________________________
447 AliQADataMaker * AliQAManager::GetQADataMaker(const Int_t iDet) 
448 {
449         // get the quality assurance data maker for a detector
450         
451   AliQADataMaker * qadm =  fQADataMaker[iDet] ; 
452   
453         if (qadm) {
454  
455     qadm->SetEventSpecie(fEventSpecie) ;  
456     if ( qadm->GetRecoParam() ) 
457       if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
458         qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ; 
459
460   } else if (iDet == AliQAv1::kGLOBAL && strcmp(GetMode(), AliQAv1::GetModeName(AliQAv1::kRECMODE)) == 0) { //Global QA
461
462                 qadm = new AliGlobalQADataMaker();
463                 qadm->SetName(AliQAv1::GetDetName(iDet));
464                 qadm->SetUniqueID(iDet);
465                 fQADataMaker[iDet] = qadm;
466     qadm->SetEventSpecie(fEventSpecie) ;  
467     if ( qadm->GetRecoParam() ) 
468       if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)  
469         qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ; 
470
471         }       else if (iDet == AliQAv1::kCORR && strcmp(GetMode(), AliQAv1::GetModeName(AliQAv1::kRECMODE)) == 0 ) { //the data maker for correlations among detectors
472     qadm = new AliCorrQADataMakerRec(fQADataMaker) ; 
473                 qadm->SetName(AliQAv1::GetDetName(iDet));
474                 qadm->SetUniqueID(iDet);
475                 fQADataMaker[iDet] = qadm;
476     qadm->SetEventSpecie(fEventSpecie) ;  
477     if ( qadm->GetRecoParam() ) 
478       if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)  
479         qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ; 
480
481   } else if ( iDet < AliQAv1::kGLOBAL ) {
482     TString  smode(GetMode()) ; 
483     if (smode.Contains(AliQAv1::GetModeName(AliQAv1::kQAMODE)))
484       smode = AliQAv1::GetModeName(AliQAv1::kRECMODE) ; 
485     // load the QA data maker object
486     TPluginManager* pluginManager = gROOT->GetPluginManager() ;
487     TString detName = AliQAv1::GetDetName(iDet) ;
488     TString qadmName = "Ali" + detName + "QADataMaker" + smode ;
489     
490     // first check if a plugin is defined for the quality assurance data maker
491     TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
492     // if not, add a plugin for it
493     if (!pluginHandler) {
494       AliDebug(AliQAv1::GetQADebugLevel(), Form("defining plugin for %s", qadmName.Data())) ;
495       TString libs = gSystem->GetLibraries() ;
496       TString temp(smode) ;
497       temp.ToLower() ; 
498       if (libs.Contains("lib" + detName + smode + ".so") || (gSystem->Load("lib" + detName + temp.Data() + ".so") >= 0)) {
499         pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName + "qadm", qadmName + "()") ;
500       } else {
501         pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName, qadmName + "()") ;
502       }
503       pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
504     }
505     if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
506       qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0) ;
507     }
508     if (qadm) {
509       qadm->SetName(AliQAv1::GetDetName(iDet));
510       qadm->SetUniqueID(iDet);
511       fQADataMaker[iDet] = qadm ;
512       qadm->SetEventSpecie(fEventSpecie) ;  
513       if ( qadm->GetRecoParam() ) 
514         if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)  
515           qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ; 
516     }
517   }
518   return qadm ;
519 }
520
521 //_____________________________________________________________________________
522 void  AliQAManager::EndOfCycle(TObjArray * detArray) 
523 {
524         // End of cycle QADataMakers 
525         
526   AliQAChecker::Instance()->SetRunNumber(fRunNumber) ; 
527   TCanvas fakeCanvas ; 
528
529     fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ; 
530         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
531                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
532                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
533                         if (!qadm) 
534                                 continue ;      
535                         // skip non active detectors
536                         if (detArray) {
537                                 AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQAv1::GetDetName(iDet))) ;
538                                 if (!det || !det->IsActive())  
539                                         continue ;
540                         }
541                         AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(iDet) ;
542       if (qac) 
543         qac->SetPrintImage(fPrintImage) ;
544       for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
545         if ( fTasks.Contains(Form("%d", taskIndex)) ) 
546           qadm->EndOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex))) ;
547       }
548                         qadm->Finish();
549                 }
550         }
551   if (fPrintImage) 
552     fakeCanvas.Print(Form("%s%s%d.%s]", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps"); 
553 }
554
555 //_____________________________________________________________________________
556 void  AliQAManager::EndOfCycle(TString detectors) 
557 {
558         // End of cycle QADataMakers 
559         
560   AliQAChecker::Instance()->SetRunNumber(fRunNumber) ; 
561   TCanvas fakeCanvas ; 
562   if (fPrintImage) 
563     fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ; 
564   for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
565                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
566                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
567                         if (!qadm) 
568                                 continue ;      
569                         // skip non active detectors
570       if (!detectors.Contains(AliQAv1::GetDetName(iDet))) 
571         continue ;
572                         AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(iDet) ;
573       if (qac) 
574         qac->SetPrintImage(fPrintImage) ;
575       for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
576         if ( fTasks.Contains(Form("%d", taskIndex)) ) 
577           qadm->EndOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex))) ;
578       }
579                         qadm->Finish();
580                 }
581         }
582   if (fPrintImage) 
583     fakeCanvas.Print(Form("%s%s%d.%s]", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps"); 
584 }
585
586 //_____________________________________________________________________________
587 AliRecoParam::EventSpecie_t AliQAManager::GetEventSpecieFromESD() 
588 {
589   AliRecoParam::EventSpecie_t runtype = AliRecoParam::kDefault ; 
590   if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
591     TFile * esdFile = TFile::Open("AliESDs.root") ;
592     TTree * esdTree = static_cast<TTree *> (esdFile->Get("esdTree")) ; 
593     if ( !esdTree ) {
594       AliError("esdTree not found") ; 
595     } else {
596       AliESDEvent * esd    = new AliESDEvent() ;
597       esd->ReadFromTree(esdTree) ;
598       esdTree->GetEntry(0) ; 
599       runtype = AliRecoParam::Convert(esd->GetEventType()) ; 
600     }
601   } else {
602     AliError("AliESDs.root not found") ; 
603   }
604   return runtype ;
605 }
606
607 //_____________________________________________________________________________
608 void AliQAManager::Increment(const AliQAv1::TASKINDEX_t taskIndex)
609 {
610   // Increments the cycle counter for all QA Data Makers
611   static AliQAv1::TASKINDEX_t currentTask = AliQAv1::kNTASKINDEX ; 
612   if ( (currentTask == taskIndex) && taskIndex != AliQAv1::kNULLTASKINDEX )
613     return ; 
614   else 
615     currentTask = taskIndex ; 
616         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
617                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
618                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
619                         if (qadm) 
620         qadm->Increment() ;
621     }
622   }
623 }
624   
625 //_____________________________________________________________________________
626 Bool_t AliQAManager::InitQA(const AliQAv1::TASKINDEX_t taskIndex, const  Char_t * input )
627 {
628         // Initialize the event source and QA data makers
629         
630         fTasks += Form("%d", taskIndex) ; 
631
632         if (taskIndex == AliQAv1::kRAWS) { 
633                 if (!fRawReader) {
634                         fRawReader = AliRawReader::Create(input);
635                 }
636                 if ( ! fRawReader ) 
637                         return kFALSE ; 
638                 fRawReaderDelete = kTRUE ; 
639                 fRawReader->NextEvent() ; 
640                 fRunNumber = fRawReader->GetRunNumber() ; 
641                 SetRun(fRunNumber) ; 
642                 fRawReader->RewindEvents();
643                 fNumberOfEvents = 999999 ;
644                 if ( fMaxEvents < 0 ) 
645                         fMaxEvents = fNumberOfEvents ; 
646                 } else if (taskIndex == AliQAv1::kESDS) {
647                         fTasks = AliQAv1::GetTaskName(AliQAv1::kESDS) ; 
648       if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
649         TFile * esdFile = TFile::Open("AliESDs.root") ;
650         fESDTree = static_cast<TTree *> (esdFile->Get("esdTree")) ; 
651         if ( !fESDTree ) {
652           AliError("esdTree not found") ; 
653           return kFALSE ; 
654         } else {
655           fESD     = new AliESDEvent() ;
656           fESD->ReadFromTree(fESDTree) ;
657           fESDTree->GetEntry(0) ; 
658           fRunNumber = fESD->GetRunNumber() ; 
659           fNumberOfEvents = fESDTree->GetEntries() ;
660           if ( fMaxEvents < 0 ) 
661             fMaxEvents = fNumberOfEvents ; 
662         }
663       } else {
664         AliError("AliESDs.root not found") ; 
665         return kFALSE ; 
666       }                 
667     } else {
668       if ( !InitRunLoader() ) { 
669         AliWarning("No Run Loader not found") ; 
670       } else {
671         fNumberOfEvents = fRunLoader->GetNumberOfEvents() ;
672         if ( fMaxEvents < 0 ) 
673           fMaxEvents = fNumberOfEvents ; 
674       }
675     }
676
677   // Get Detectors 
678   TObjArray* detArray = NULL ; 
679         if (fRunLoader) // check if RunLoader exists 
680                 if ( fRunLoader->GetAliRun() ) { // check if AliRun exists in gAlice.root
681                         detArray = fRunLoader->GetAliRun()->Detectors() ;
682                         fRunNumber = fRunLoader->GetHeader()->GetRun() ; 
683                 }
684
685         // Initialize all QA data makers for all detectors
686         fRunNumber = AliCDBManager::Instance()->GetRun() ; 
687         if ( !  AliGeomManager::GetGeometry() ) 
688                 AliGeomManager::LoadGeometry() ; 
689         
690         InitQADataMaker(fRunNumber, detArray) ; //, fCycleSame, kTRUE, detArray) ; 
691   if (fPrintImage) {
692     TCanvas fakeCanvas ; 
693     TStopwatch timer ; 
694     timer.Start() ; 
695     while (timer.CpuTime()<5) {
696       timer.Continue();
697       gSystem->ProcessEvents();
698     }
699     fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ;    
700   }    
701         return kTRUE ; 
702 }
703
704 //_____________________________________________________________________________
705 void  AliQAManager::InitQADataMaker(UInt_t run, TObjArray * detArray) 
706 {
707         // Initializes The QADataMaker for all active detectors and for all active tasks 
708   fRunNumber = run ; 
709         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
710                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
711                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
712                         if (!qadm) {
713                                 AliError(Form("AliQADataMaker not found for %s", AliQAv1::GetDetName(iDet))) ; 
714                                 fDetectorsW.ReplaceAll(AliQAv1::GetDetName(iDet), "") ; 
715                         } else {
716         if (fQAWriteExpert[iDet])
717           qadm->SetWriteExpert() ; 
718                                 AliDebug(AliQAv1::GetQADebugLevel(), Form("Data Maker found for %s %d", qadm->GetName(), qadm->WriteExpert())) ; 
719                                 // skip non active detectors
720                                 if (detArray) {
721                                         AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQAv1::GetDetName(iDet))) ;
722                                         if (!det || !det->IsActive())  
723                                                 continue ;
724                                 }
725               // Set default reco params
726         Bool_t sameCycle = kFALSE ; 
727                                 for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
728                                         if ( fTasks.Contains(Form("%d", taskIndex)) ) {
729                                                 qadm->Init(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), GetQACycles(qadm->GetUniqueID())) ;
730             qadm->StartOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), run,  sameCycle) ;
731             sameCycle = kTRUE ;
732                                         }
733                                 }
734                         }
735                 }
736         }
737 }
738
739
740 //_____________________________________________________________________________
741 Bool_t AliQAManager::InitRunLoader()
742 {
743         // get or create the run loader
744         if (fRunLoader) {
745                 fCycleSame = kTRUE ; 
746         } else {
747                 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
748                         // load all base libraries to get the loader classes
749                         TString libs = gSystem->GetLibraries() ;
750                         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
751                                 if (!IsSelected(AliQAv1::GetDetName(iDet))) 
752                                         continue ; 
753                                 TString detName = AliQAv1::GetDetName(iDet) ;
754                                 if (detName == "HLT") 
755                                         continue;
756                                 if (libs.Contains("lib" + detName + "base.so")) 
757                                         continue;
758                                 gSystem->Load("lib" + detName + "base.so");
759                         }
760                         fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
761                         if (!fRunLoader) {
762                                 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
763                                 return kFALSE;
764                         }
765                         fRunLoader->CdGAFile();
766                         if (fRunLoader->LoadgAlice() == 0) {
767                                 gAlice = fRunLoader->GetAliRun();
768                         }
769
770                         if (!gAlice) {
771                                 AliError(Form("no gAlice object found in file %s", fGAliceFileName.Data()));
772                                 return kFALSE;
773                         }
774
775                 } else {               // galice.root does not exist
776                         AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
777                         return kFALSE;
778                 }
779         }
780
781         if (!fRunNumber) { 
782                 fRunLoader->LoadHeader();
783                 fRunNumber = fRunLoader->GetHeader()->GetRun() ; 
784         }
785         return kTRUE;
786 }
787
788 //_____________________________________________________________________________
789 Bool_t AliQAManager::IsSelected(const Char_t * det) 
790 {
791   // check whether detName is contained in detectors
792         // if yes, it is removed from detectors
793         
794         Bool_t rv = kFALSE;
795         const TString detName(det) ;
796   // always activates Correlation
797   if ( detName.Contains(AliQAv1::GetDetName(AliQAv1::kCORR)) || detName.Contains(AliQAv1::GetDetName(AliQAv1::kGLOBAL))) {
798     rv = kTRUE ; 
799   } else {
800     // check if all detectors are selected
801     if (fDetectors.Contains("ALL")) {
802       fDetectors = "ALL";
803       rv = kTRUE;
804     } else if ((fDetectors.CompareTo(detName) == 0) ||
805                fDetectors.BeginsWith(detName+" ") ||
806                fDetectors.EndsWith(" "+detName) ||
807                fDetectors.Contains(" "+detName+" ")) {
808       rv = kTRUE;
809     }
810   }
811         return rv ;
812 }
813
814 //_____________________________________________________________________________
815 Bool_t AliQAManager::Merge(Int_t runNumber, const char *fileName) const
816 {
817         // Merge data from all detectors from a given run in one single file 
818         // Merge the QA results from all the data chunks in one run
819   // The 'fileName' is name of the output file with merged QA data  
820  if ( runNumber == -1)
821    runNumber = fRunNumber ; 
822  Bool_t rv = MergeData(runNumber,fileName) ; 
823  //rv *= MergeResults(runNumber) ; // not needed for the time being
824  return rv ; 
825 }
826         
827 //______________________________________________________________________
828 Bool_t AliQAManager::MergeXML(const Char_t * collectionFile, const Char_t * subFile, const Char_t * outFile) 
829 {
830   // merges files listed in a xml collection 
831   // usage Merge(collection, outputFile))
832   //              collection: is a xml collection  
833   
834   Bool_t rv = kFALSE ; 
835   
836   if ( strstr(collectionFile, ".xml") == 0 ) {
837     AliError("Input collection file must be an \".xml\" file\n") ; 
838     return kFALSE ; 
839   }
840     
841  if ( !gGrid ) 
842    TGrid::Connect("alien://"); 
843  if ( !gGrid ) 
844    return kFALSE ; 
845  
846   // Open the file collection 
847   AliInfoClass(Form("*** Create Collection       ***\n***  Wk-Dir = |%s|             \n***  Coll   = |%s|             \n",gSystem->WorkingDirectory(), collectionFile));                
848   
849   TGridCollection * collection = (TGridCollection*)gROOT->ProcessLine(Form("TAlienCollection::Open(\"%s\")",collectionFile));
850   TGridResult* result = collection->GetGridResult("", 0, 0);
851   
852   Int_t index = 0  ;
853   const Char_t * turl ;
854   TFileMerger merger(kFALSE) ; 
855   if (!outFile) {
856     TString tempo(collectionFile) ; 
857     if ( subFile) 
858       tempo.ReplaceAll(".xml", subFile) ; 
859     else 
860       tempo.ReplaceAll(".xml", "_Merged.root") ; 
861     outFile = tempo.Data() ; 
862   }
863   merger.OutputFile(outFile) ; 
864   
865   while ( (turl = result->GetKey(index, "turl")) ) {
866     Char_t * file ;
867     if ( subFile )
868       file = Form("%s#%s", turl, subFile) ; 
869     else 
870       file = Form("%s", turl) ; 
871     
872     AliDebug(AliQAv1::GetQADebugLevel(), Form("%s\n", file)) ; 
873     merger.AddFile(file) ; 
874     index++ ;  
875   }
876   
877   if (index) 
878     merger.Merge() ; 
879   
880   AliDebug(AliQAv1::GetQADebugLevel(), Form("Files merged into %s\n", outFile)) ;
881   
882   rv = kFALSE;
883   return rv ;
884 }
885
886 //_____________________________________________________________________________
887 void AliQAManager::MergeCustom() const
888 {
889         // Custom Merge of QA data from all detectors for all runs in one single file 
890   // search all the run numbers
891   // search all the run numbers
892   gROOT->ProcessLine(".! ls *QA*.root > QAtempo.txt") ;
893   TString QAfile ; 
894   FILE * QAfiles = fopen("QAtempo.txt", "r") ; 
895   Int_t index = 0 ; 
896   TList srunList ; 
897   TIter nextRun(&srunList) ; 
898   TObjString * srun = NULL ; 
899   Int_t loRun = 999999999 ; 
900   Int_t hiRun = 0 ; 
901   while ( QAfile.Gets(QAfiles) ) {
902     Bool_t runExist = kFALSE ; 
903     TString srunNew(QAfile(QAfile.Index("QA.")+3, QAfile.Index(".root")-(QAfile.Index("QA.")+3))) ; 
904     Int_t cuRun = srunNew.Atoi() ;
905     if (cuRun < loRun) 
906       loRun = cuRun ; 
907     if (cuRun > hiRun)
908       hiRun = cuRun ; 
909     while ( (srun = static_cast<TObjString *> (nextRun())) ) {
910       if ( cuRun == (srun->String()).Atoi() ) {
911         runExist = kTRUE ; 
912         break ; 
913       } 
914     }
915     nextRun.Reset() ; 
916     if ( ! runExist ) 
917       srunList.Add(new TObjString(srunNew.Data()));
918   }
919   nextRun.Reset() ;    
920   Int_t runNumber = 0 ; 
921   TFile mergedFile(Form("Merged.%s.Data.root", AliQAv1::GetQADataFileName()), "RECREATE") ; 
922   TH1I * hisRun = new TH1I("hLMR", "List of merged runs", hiRun-loRun+10, loRun, hiRun+10) ; 
923   // create the structure into the merged file
924   for (Int_t iDet = 0; iDet < AliQAv1::kNDET ; iDet++) {
925     TDirectory * detDir = mergedFile.mkdir(AliQAv1::GetDetName(iDet)) ; 
926     for (Int_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
927       detDir->cd() ; 
928       TDirectory * taskDir = gDirectory->mkdir(AliQAv1::GetTaskName(taskIndex)) ; 
929       for (Int_t es = 0 ; es < AliRecoParam::kNSpecies ; es++) {
930         taskDir->cd() ; 
931         TDirectory * esDir = gDirectory->mkdir(AliRecoParam::GetEventSpecieName(es)) ;
932         esDir->cd() ; 
933         gDirectory->mkdir(AliQAv1::GetExpert()) ; 
934       }
935     }
936   }
937   while ( (srun = static_cast<TObjString *> (nextRun())) ) {
938     runNumber = (srun->String()).Atoi() ; 
939     hisRun->Fill(runNumber) ; 
940     AliDebug(AliQAv1::GetQADebugLevel(), Form("Merging run number %d", runNumber)) ; 
941     // search all QA files for runNumber in the current directory
942     Char_t * fileList[AliQAv1::kNDET] ;
943     index = 0 ; 
944     for (Int_t iDet = 0; iDet < AliQAv1::kNDET ; iDet++) {
945       Char_t * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQAv1::GetDetName(iDet), AliQAv1::GetQADataFileName(), runNumber)); 
946       if (file) 
947         fileList[index++] = file ;
948     }
949     if ( index == 0 ) {
950       AliError("No QA data file found\n") ; 
951       return ; 
952     }
953     for ( Int_t i = 0 ; i < index ; i++) {
954       TFile * inFile = TFile::Open(fileList[i]) ;  
955       TList * listOfKeys =inFile->GetListOfKeys() ; 
956       TIter nextkey(listOfKeys) ; 
957       TObject * obj1 ; 
958       TString dirName("") ; 
959       while ( (obj1 = nextkey()) ) {
960         TDirectory * directoryDet = inFile->GetDirectory(obj1->GetName()) ; 
961         if ( directoryDet ) {
962           AliDebug(AliQAv1::GetQADebugLevel(), Form("%s dir = %s", inFile->GetName(), directoryDet->GetName())) ; 
963           dirName += Form("%s/", directoryDet->GetName() ) ; 
964           directoryDet->cd() ;
965           TList * listOfTasks = directoryDet->GetListOfKeys() ; 
966           TIter nextTask(listOfTasks) ; 
967           TObject * obj2 ; 
968           while ( (obj2 = nextTask()) ) {
969             TDirectory * directoryTask = directoryDet->GetDirectory(obj2->GetName()) ; 
970             if ( directoryTask ) {
971               dirName += Form("%s", obj2->GetName()) ; 
972               AliDebug(AliQAv1::GetQADebugLevel(), Form("%s", dirName.Data())) ; 
973               directoryTask->cd() ; 
974               TList * listOfEventSpecie = directoryTask->GetListOfKeys() ; 
975               TIter nextEventSpecie(listOfEventSpecie) ; 
976               TObject * obj3 ; 
977               while ( (obj3 = nextEventSpecie()) ) {
978                 TDirectory * directoryEventSpecie = directoryTask->GetDirectory(obj3->GetName()) ; 
979                 if ( directoryEventSpecie ) {
980                   dirName += Form("/%s/", obj3->GetName()) ; 
981                   AliDebug(AliQAv1::GetQADebugLevel(), Form("%s\n", dirName.Data())) ; 
982                   directoryEventSpecie->cd() ; 
983                   // histograms are here
984                   TDirectory * mergedDirectory = mergedFile.GetDirectory(dirName.Data()) ;
985                   TList * listOfData = directoryEventSpecie->GetListOfKeys() ; 
986                   TIter nextData(listOfData) ; 
987                   TKey * key ; 
988                   while ( (key = static_cast<TKey *>(nextData())) ) {
989                     TString className(key->GetClassName()) ; 
990                     if (  className.Contains("TH") || className.Contains("TProfile") ) {
991                       TH1 * histIn = static_cast<TH1*> (key->ReadObj()) ; 
992                       TH1 * histOu = static_cast<TH1*> (mergedDirectory->FindObjectAny(histIn->GetName())) ; 
993                       AliDebug(AliQAv1::GetQADebugLevel(), Form("%s %p %p\n", key->GetName(), histIn, histOu)) ; 
994                       mergedDirectory->cd() ; 
995                       if ( ! histOu ) {
996                         histIn->Write() ; 
997                       } else {
998                         histOu->Add(histIn) ; 
999                         histOu->Write(histOu->GetName(), kOverwrite) ; 
1000                       }
1001                     }
1002                     else if ( className.Contains("TDirectoryFile") ) {
1003                       TDirectory * dirExpert = directoryEventSpecie->GetDirectory(key->GetName()) ; 
1004                       dirExpert->cd() ; 
1005                       TDirectory * mergedDirectoryExpert = mergedDirectory->GetDirectory(dirExpert->GetName()) ; 
1006                       TList * listOfExpertData = dirExpert->GetListOfKeys() ; 
1007                       TIter nextExpertData(listOfExpertData) ; 
1008                       TKey * keykey ; 
1009                       while ( (keykey = static_cast<TKey *>(nextExpertData())) ) {
1010                         TString classNameExpert(keykey->GetClassName()) ; 
1011                         if (classNameExpert.Contains("TH")) {
1012                           TH1 * histInExpert = static_cast<TH1*> (keykey->ReadObj()) ; 
1013                           TH1 * histOuExpert = static_cast<TH1*> (mergedDirectory->FindObjectAny(histInExpert->GetName())) ; 
1014                           mergedDirectoryExpert->cd() ; 
1015                           if ( ! histOuExpert ) {
1016                             histInExpert->Write() ; 
1017                           } else {
1018                             histOuExpert->Add(histInExpert) ; 
1019                             histOuExpert->Write(histOuExpert->GetName(), kOverwrite) ; 
1020                           }
1021                         }
1022                       }
1023                     } else {
1024                       AliError(Form("No merge done for this object %s in %s", key->GetName(), dirName.Data())) ; 
1025                     }
1026                   }
1027                   dirName.ReplaceAll(Form("/%s/",obj3->GetName()), "") ; 
1028                 }
1029               }
1030               dirName.ReplaceAll(obj2->GetName(), "") ; 
1031             }
1032           }
1033         }
1034       }
1035       inFile->Close() ; 
1036     }
1037   }
1038   mergedFile.cd() ;
1039   hisRun->Write() ; 
1040   mergedFile.Close() ; 
1041   srunList.Delete() ;   
1042 }
1043
1044 //_____________________________________________________________________________
1045 Bool_t AliQAManager::MergeData(const Int_t runNumber, const char *fileName) const
1046 {
1047         // Merge QA data from all detectors for a given run in one single file 
1048   
1049   TFileMerger merger(kFALSE) ; 
1050   TString outFileName = fileName;
1051   if (outFileName.IsNull()) outFileName.Form("Merged.%s.Data.root",AliQAv1::GetQADataFileName());
1052   merger.OutputFile(outFileName.Data()) ; 
1053   for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
1054     Char_t * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQAv1::GetDetName(iDet), AliQAv1::GetQADataFileName(), runNumber)); 
1055     if (file) 
1056       merger.AddFile(file);
1057     delete[] file;
1058   }
1059   merger.Merge() ; 
1060         return kTRUE ; 
1061 }
1062
1063 //_____________________________________________________________________________
1064 Bool_t AliQAManager::MergeResults(const Int_t runNumber) const
1065 {
1066         // Merge the QA result from all the data chunks in a run 
1067   // to be revised whwn it will be used (see MergeData)
1068         TString cmd ;
1069         cmd = Form(".! ls %s*.root > tempo.txt", AliQAv1::GetQADataFileName()) ; 
1070         gROOT->ProcessLine(cmd.Data()) ;
1071         ifstream in("tempo.txt") ; 
1072         const Int_t chunkMax = 100 ;  
1073         TString fileList[chunkMax] ;
1074         
1075         Int_t index = 0 ; 
1076         while ( 1 ) {
1077                 TString file ; 
1078                 in >> fileList[index] ; 
1079                 if ( !in.good() ) 
1080                         break ; 
1081                 AliDebug(AliQAv1::GetQADebugLevel(), Form("index = %d file = %s", index, (fileList[index].Data()))) ; 
1082                 index++ ;
1083         }
1084         
1085         if ( index == 0 ) { 
1086                 AliError("No QA Result File found") ; 
1087                 return kFALSE ; 
1088         }
1089         
1090         TFileMerger merger ; 
1091   TString outFileName ;
1092   if (runNumber != -1) 
1093     outFileName = Form("Merged.%s.Result.%d.root",AliQAv1::GetQADataFileName(),runNumber); 
1094   else 
1095     outFileName = Form("Merged.%s.Result.root",AliQAv1::GetQADataFileName()); 
1096         merger.OutputFile(outFileName.Data()) ; 
1097         for (Int_t ifile = 0 ; ifile < index ; ifile++) {
1098                 TString file = fileList[ifile] ; 
1099                 merger.AddFile(file) ; 
1100         }
1101         merger.Merge() ; 
1102         
1103         return kTRUE ; 
1104 }
1105
1106 //_____________________________________________________________________________
1107 void AliQAManager::Reset(const Bool_t sameCycle)
1108 {
1109         // Reset the default data members
1110
1111         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
1112                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
1113                         AliQADataMaker * qadm = GetQADataMaker(iDet);
1114                         if (qadm) 
1115         qadm->Reset();
1116                 }
1117         } 
1118         if (fRawReaderDelete) { 
1119                 delete fRawReader ;
1120                 fRawReader      = NULL ;
1121         }
1122
1123         fCycleSame      = sameCycle ; 
1124         fESD            = NULL ; 
1125         fESDTree        = NULL ; 
1126         //fFirst          = kTRUE ;   
1127         fNumberOfEvents = 999999 ;  
1128 }
1129
1130 //_____________________________________________________________________________
1131 void AliQAManager::ResetDetectors(AliQAv1::TASKINDEX_t task, AliQAv1::DETECTORINDEX_t det)
1132 {
1133     //calls ResetDetector of specified or all detectors
1134   UInt_t iDet    = 0 ;
1135   UInt_t iDetMax = fgkNDetectors ;    
1136   if ( det != AliQAv1::kNULLDET ) {
1137     iDet    = det ;
1138     iDetMax = det+1 ;    
1139   }
1140   
1141         for (iDet = 0; iDet < iDetMax ; iDet++) {
1142                 if (IsSelected(AliQAv1::GetDetName(iDet))) {
1143                         AliQADataMaker * qadm = GetQADataMaker(iDet);
1144                         qadm->ResetDetector(task);
1145                 }
1146         }   
1147 }
1148
1149 //_____________________________________________________________________________
1150 AliQAManager * AliQAManager::QAManager(AliQAv1::MODE_t mode, TMap *entryCache, Int_t run) 
1151 {
1152   // returns AliQAManager instance (singleton)
1153   
1154         if (!fgQAInstance) {
1155     if ( (mode != AliQAv1::kSIMMODE) && (mode != AliQAv1::kRECMODE) && (mode != AliQAv1::kQAMODE) ) {
1156       AliWarningClass("You must specify kSIMMODE or kRECMODE or kQAMODE") ; 
1157       return NULL ; 
1158     }
1159     fgQAInstance = new AliQAManager(mode) ;  
1160     if (!entryCache)
1161                   fgQAInstance->Init();
1162                 else
1163                   fgQAInstance->InitFromCache(entryCache,run);
1164   }
1165         return fgQAInstance;
1166 }
1167
1168 //_____________________________________________________________________________
1169 AliQAManager * AliQAManager::QAManager(AliQAv1::TASKINDEX_t task) 
1170 {
1171   // returns AliQAManager instance (singleton)
1172   return QAManager(AliQAv1::Mode(task)) ; 
1173 }
1174
1175 //_____________________________________________________________________________
1176 TString AliQAManager::Run(const Char_t * detectors, AliRawReader * rawReader, const Bool_t sameCycle) 
1177 {
1178         //Runs all the QA data Maker for Raws only
1179         
1180         fCycleSame       = sameCycle ;
1181         fRawReader       = rawReader ;
1182         fDetectors       = detectors ; 
1183         fDetectorsW      = detectors ;  
1184         
1185         AliCDBManager* man = AliCDBManager::Instance() ; 
1186
1187         if ( man->GetRun() == -1 ) {// check if run number not set previously and set it from raw data
1188                 rawReader->NextEvent() ; 
1189                 man->SetRun(fRawReader->GetRunNumber()) ;
1190                 rawReader->RewindEvents() ;
1191         }       
1192         
1193         if (!fCycleSame) 
1194     if ( !InitQA(AliQAv1::kRAWS) ) 
1195       return "" ; 
1196   fRawReaderDelete = kFALSE ; 
1197
1198         DoIt(AliQAv1::kRAWS) ; 
1199         return  fDetectorsW ;
1200 }
1201
1202 //_____________________________________________________________________________
1203 TString AliQAManager::Run(const Char_t * detectors, const Char_t * fileName, const Bool_t sameCycle) 
1204 {
1205         //Runs all the QA data Maker for Raws only
1206
1207         fCycleSame       = sameCycle ;
1208         fDetectors       = detectors ; 
1209         fDetectorsW      = detectors ;  
1210         
1211         AliCDBManager* man = AliCDBManager::Instance() ; 
1212         if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
1213                 AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
1214                 if ( ! rl ) {
1215                         AliFatal("galice.root file not found in current directory") ; 
1216                 } else {
1217                         rl->CdGAFile() ; 
1218                         rl->LoadgAlice() ;
1219                         if ( ! rl->GetAliRun() ) {
1220                                 AliFatal("AliRun not found in galice.root") ;
1221                         } else {
1222                                 rl->LoadHeader() ;
1223                                 man->SetRun(rl->GetHeader()->GetRun());
1224                         }
1225                 }
1226         }
1227         
1228         if (!fCycleSame) 
1229     if ( !InitQA(AliQAv1::kRAWS, fileName) ) 
1230       return "" ; 
1231         
1232         DoIt(AliQAv1::kRAWS) ; 
1233         return  fDetectorsW ;
1234 }
1235
1236 //_____________________________________________________________________________
1237 TString AliQAManager::Run(const Char_t * detectors, const AliQAv1::TASKINDEX_t taskIndex, Bool_t const sameCycle, const  Char_t * fileName ) 
1238 {
1239         // Runs all the QA data Maker for every detector
1240         
1241         fCycleSame       = sameCycle ;
1242         fDetectors       = detectors ; 
1243         fDetectorsW      = detectors ;          
1244         
1245         AliCDBManager* man = AliCDBManager::Instance() ;        
1246         if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
1247                 AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
1248                 if ( ! rl ) {
1249                         AliFatal("galice.root file not found in current directory") ; 
1250                 } else {
1251                         rl->CdGAFile() ; 
1252                         rl->LoadgAlice() ;
1253                         if ( ! rl->GetAliRun() ) {
1254                                 AliDebug(AliQAv1::GetQADebugLevel(), "AliRun not found in galice.root") ;
1255                         } else {
1256                                 rl->LoadHeader() ;
1257                                 man->SetRun(rl->GetHeader()->GetRun()) ;
1258                         }
1259                 }
1260         }
1261   if ( taskIndex == AliQAv1::kNULLTASKINDEX) { 
1262                 for (UInt_t task = 0; task < AliQAv1::kNTASKINDEX; task++) {
1263                         if ( fTasks.Contains(Form("%d", task)) ) {
1264         if (!fCycleSame)
1265           if ( !InitQA(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(task)), fileName) ) 
1266             return "" ;
1267         DoIt(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(task))) ;
1268                         }
1269                 }
1270         } else {
1271     if (! fCycleSame )
1272       if ( !InitQA(taskIndex, fileName) ) 
1273         return "" ; 
1274       DoIt(taskIndex) ; 
1275   }             
1276         return fDetectorsW ;
1277 }
1278
1279 //_____________________________________________________________________________
1280 void AliQAManager::RunOneEvent(AliRawReader * rawReader) 
1281 {
1282         //Runs all the QA data Maker for Raws only and on one event only (event loop done by calling method)
1283   if ( ! rawReader ) 
1284     return ; 
1285   if (fTasks.Contains(Form("%d", AliQAv1::kRAWS))){
1286     for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1287       if (!IsSelected(AliQAv1::GetDetName(iDet))) 
1288         continue;
1289       AliQADataMaker *qadm = GetQADataMaker(iDet);  
1290       if (!qadm) 
1291         continue;
1292       if ( qadm->IsCycleDone() ) {
1293         qadm->EndOfCycle() ;
1294       }
1295       qadm->SetEventSpecie(fEventSpecie) ;  
1296       if ( qadm->GetRecoParam() ) 
1297         if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)  
1298           qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ; 
1299                         qadm->Exec(AliQAv1::kRAWS, rawReader) ;
1300                 }
1301   }
1302 }
1303
1304 //_____________________________________________________________________________
1305 void AliQAManager::RunOneEvent(AliESDEvent *& esd, AliESDEvent *& hltesd) 
1306 {
1307         //Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
1308         
1309   if (fTasks.Contains(Form("%d", AliQAv1::kESDS))) {
1310     for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1311       if (!IsSelected(AliQAv1::GetDetName(iDet))) 
1312         continue;
1313       AliQADataMaker *qadm = GetQADataMaker(iDet);  
1314       if (!qadm) 
1315         continue;
1316       qadm->SetEventSpecie(fEventSpecie) ;  
1317       if ( qadm->GetRecoParam() ) 
1318         if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)  
1319           qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ; 
1320       if ( qadm->IsCycleDone() ) {
1321         qadm->EndOfCycle() ;
1322       }
1323       if (iDet == AliQAv1::kHLT) {
1324         TObjArray esdarray;
1325         esdarray.Add(esd); 
1326         esdarray.Add(hltesd); 
1327         qadm->Exec(AliQAv1::kESDS, &esdarray);
1328       } else {
1329         qadm->Exec(AliQAv1::kESDS, esd) ;        
1330       }
1331                 }
1332         }
1333 }
1334
1335 //_____________________________________________________________________________
1336 void AliQAManager::RunOneEventInOneDetector(Int_t det, TTree * tree) 
1337 {
1338         // Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
1339   
1340   TString test(tree->GetName()) ; 
1341   if (fTasks.Contains(Form("%d", AliQAv1::kRECPOINTS))) {
1342     if (IsSelected(AliQAv1::GetDetName(det))) {
1343       AliQADataMaker *qadm = GetQADataMaker(det);  
1344       if (qadm) { 
1345         qadm->SetEventSpecie(fEventSpecie) ;  
1346         if ( qadm->GetRecoParam() ) {
1347           if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)  
1348             qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ; 
1349           else
1350             AliError(Form("%d defined by %s is not an event specie", qadm->GetRecoParam()->GetEventSpecie(), qadm->GetName())) ; 
1351         }                    
1352         if ( qadm->IsCycleDone() ) {
1353           qadm->EndOfCycle() ;
1354         }
1355         if (test.Contains("TreeD")) {
1356           qadm->Exec(AliQAv1::kDIGITSR, tree) ;
1357         } else  if (test.Contains("TreeR")) {
1358           qadm->Exec(AliQAv1::kRECPOINTS, tree) ;
1359         }
1360       }
1361     }
1362   }
1363 }
1364
1365 //_____________________________________________________________________________
1366 Bool_t AliQAManager::Save2OCDB(const Int_t runNumber, AliRecoParam::EventSpecie_t es, const Char_t * year, const Char_t * detectors) const
1367 {
1368         // take the locasl QA data merge into a single file and save in OCDB 
1369         Bool_t rv = kTRUE ; 
1370         TString tmp(AliQAv1::GetQARefStorage()) ; 
1371         if ( tmp.IsNull() ) { 
1372                 AliError("No storage defined, use AliQAv1::SetQARefStorage") ; 
1373                 return kFALSE ; 
1374         }
1375         if ( !(tmp.Contains(AliQAv1::GetLabLocalOCDB()) || tmp.Contains(AliQAv1::GetLabAliEnOCDB())) ) {
1376                 AliError(Form("%s is a wrong storage, use %s or %s", AliQAv1::GetQARefStorage(), AliQAv1::GetLabLocalOCDB().Data(), AliQAv1::GetLabAliEnOCDB().Data())) ; 
1377                 return kFALSE ; 
1378         }
1379         TString sdet(detectors) ; 
1380         sdet.ToUpper() ;
1381         TFile * inputFile ; 
1382         if ( sdet.Contains("ALL") ) {
1383                 rv = Merge(runNumber) ; 
1384                 if ( ! rv )
1385                         return kFALSE ; 
1386                 TString inputFileName(Form("Merged.%s.Data.%d.root", AliQAv1::GetQADataFileName(), runNumber)) ; 
1387                 inputFile = TFile::Open(inputFileName.Data()) ; 
1388                 rv = SaveIt2OCDB(runNumber, inputFile, year, es) ; 
1389         } else {
1390                 for (Int_t index = 0; index < AliQAv1::kNDET; index++) {
1391                         if (sdet.Contains(AliQAv1::GetDetName(index))) {
1392                                 TString inputFileName(Form("%s.%s.%d.root", AliQAv1::GetDetName(index), AliQAv1::GetQADataFileName(), runNumber)) ; 
1393                                 inputFile = TFile::Open(inputFileName.Data()) ;                         
1394                                 rv *= SaveIt2OCDB(runNumber, inputFile, year, es) ; 
1395                         }
1396                 }
1397         }
1398         return rv ; 
1399 }
1400
1401 //_____________________________________________________________________________
1402 Bool_t AliQAManager::SaveIt2OCDB(const Int_t runNumber, TFile * inputFile, const Char_t * year, AliRecoParam::EventSpecie_t es) const
1403 {
1404         // reads the TH1 from file and adds it to appropriate list before saving to OCDB
1405         Bool_t rv = kTRUE ;
1406         AliDebug(AliQAv1::GetQADebugLevel(), Form("Saving TH1s in %s to %s", inputFile->GetName(), AliQAv1::GetQARefStorage())) ; 
1407         if ( ! IsDefaultStorageSet() ) {
1408                 TString tmp( AliQAv1::GetQARefStorage() ) ; 
1409                 if ( tmp.Contains(AliQAv1::GetLabLocalOCDB()) ) 
1410                         Instance()->SetDefaultStorage(AliQAv1::GetQARefStorage()) ;
1411                 else {
1412                         TString tmp1(AliQAv1::GetQARefDefaultStorage()) ; 
1413                         tmp1.Append(year) ; 
1414                         tmp1.Append("?user=alidaq") ; 
1415                         Instance()->SetDefaultStorage(tmp1.Data()) ; 
1416                 }
1417         }
1418         Instance()->SetSpecificStorage("*", AliQAv1::GetQARefStorage()) ; 
1419         if(GetRun() < 0) 
1420                 Instance()->SetRun(runNumber);
1421
1422         AliCDBMetaData mdr ;
1423         mdr.SetResponsible("yves schutz");
1424
1425         for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++) {
1426                 TDirectory * detDir = inputFile->GetDirectory(AliQAv1::GetDetName(detIndex)) ; 
1427                 if ( detDir ) {
1428                         AliDebug(AliQAv1::GetQADebugLevel(), Form("Entering %s", detDir->GetName())) ;
1429       AliQAv1::SetQARefDataDirName(es) ;
1430                         TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetDetName(detIndex), AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName())) ; 
1431                         AliCDBId idr(detOCDBDir.Data(), runNumber, AliCDBRunRange::Infinity())  ;
1432                         TList * listDetQAD = new TList() ;
1433                         TString listName(Form("%s QA data Reference", AliQAv1::GetDetName(detIndex))) ; 
1434                         mdr.SetComment(Form("%s QA stuff", AliQAv1::GetDetName(detIndex)));
1435                         listDetQAD->SetName(listName) ; 
1436                         TList * taskList = detDir->GetListOfKeys() ; 
1437                         TIter nextTask(taskList) ; 
1438                         TKey * taskKey ; 
1439                         while ( (taskKey = static_cast<TKey*>(nextTask())) ) {
1440                                 TDirectory * taskDir = detDir->GetDirectory(taskKey->GetName()) ; 
1441         TDirectory * esDir   = taskDir->GetDirectory(AliRecoParam::GetEventSpecieName(es)) ; 
1442                                 AliDebug(AliQAv1::GetQADebugLevel(), Form("Saving %s", esDir->GetName())) ; 
1443                                 TObjArray * listTaskQAD = new TObjArray(100) ; 
1444                                 listTaskQAD->SetName(Form("%s/%s", taskKey->GetName(), AliRecoParam::GetEventSpecieName(es))) ;
1445                                 listDetQAD->Add(listTaskQAD) ; 
1446                                 TList * histList = esDir->GetListOfKeys() ; 
1447                                 TIter nextHist(histList) ; 
1448                                 TKey * histKey ; 
1449                                 while ( (histKey = static_cast<TKey*>(nextHist())) ) {
1450                                         TObject * odata = esDir->Get(histKey->GetName()) ; 
1451                                         if ( !odata ) {
1452                                                 AliError(Form("%s in %s/%s returns a NULL pointer !!", histKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
1453                                         } else {
1454             if ( AliQAv1::GetExpert() == histKey->GetName() ) {
1455               TDirectory * expertDir   = esDir->GetDirectory(histKey->GetName()) ; 
1456               TList * expertHistList = expertDir->GetListOfKeys() ; 
1457               TIter nextExpertHist(expertHistList) ; 
1458               TKey * expertHistKey ; 
1459               while ( (expertHistKey = static_cast<TKey*>(nextExpertHist())) ) {
1460                 TObject * expertOdata = expertDir->Get(expertHistKey->GetName()) ; 
1461                 if ( !expertOdata ) {
1462                   AliError(Form("%s in %s/%s/Expert returns a NULL pointer !!", expertHistKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
1463                 } else {
1464                   AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", expertHistKey->GetName())) ;
1465                   if ( expertOdata->IsA()->InheritsFrom("TH1") ) {
1466                     AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", expertHistKey->GetName())) ;
1467                     TH1 * hExpertdata = static_cast<TH1*>(expertOdata) ; 
1468                     listTaskQAD->Add(hExpertdata) ; 
1469                   }                  
1470                 }                
1471               }
1472             }
1473                                                 AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", histKey->GetName())) ;
1474                                                 if ( odata->IsA()->InheritsFrom("TH1") ) {
1475                                                         AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", histKey->GetName())) ;
1476                                                         TH1 * hdata = static_cast<TH1*>(odata) ; 
1477                                                         listTaskQAD->Add(hdata) ; 
1478                                                 }
1479                                         }
1480                                 }
1481                         }
1482                         Instance()->Put(listDetQAD, idr, &mdr) ;
1483                 }
1484         }
1485         return rv ; 
1486 }       
1487
1488 //_____________________________________________________________________________
1489
1490 void AliQAManager::SetCheckerExternParam(AliQAv1::DETECTORINDEX_t detIndex, TList * parameterList) 
1491 {
1492   // set the external parameters list for the detector checkers 
1493   AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(detIndex) ; 
1494   qac->SetExternParamlist(parameterList) ; 
1495   qac->PrintExternParam() ;  
1496 }
1497
1498 //_____________________________________________________________________________
1499 void AliQAManager::SetEventSpecie(AliRecoParam::EventSpecie_t es) 
1500 {
1501   // set the current event specie and inform AliQAv1 that this event specie has been encountered
1502   fEventSpecie = es ; 
1503   AliQAv1::Instance()->SetEventSpecie(es) ; 
1504 }
1505
1506 //_____________________________________________________________________________
1507 void AliQAManager::SetRecoParam(const Int_t det, const AliDetectorRecoParam *par) 
1508 {
1509   // Set custom reconstruction parameters for a given detector
1510   // Single set of parameters for all the events
1511   GetQADataMaker(det)->SetRecoParam(par) ; 
1512 }
1513
1514 //_____________________________________________________________________________
1515 void AliQAManager::SetWriteExpert()
1516 {
1517   // enable the writing of QA expert data
1518   for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1519         if (IsSelected(AliQAv1::GetDetName(iDet))) 
1520       fQAWriteExpert[iDet] = kTRUE ;
1521   }
1522 }  
1523
1524 //_____________________________________________________________________________
1525 void AliQAManager::Destroy() {
1526   // delete AliQAManager instance and
1527   // all associated objects
1528
1529   if (fgQAInstance) {
1530     delete fgQAInstance ;
1531     fgQAInstance = NULL ;
1532   }
1533 }
1534
1535 //_____________________________________________________________________________
1536 void AliQAManager::ShowQA() {
1537   // Show the result of the QA checking
1538   // for all detectors 
1539         for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++) 
1540     AliQAv1::Instance(AliQAv1::GetDetIndex(AliQAv1::GetDetName(detIndex)))->Show() ; 
1541 }