TList replaced by TObjArray as QA data container. Introducing OCDB for the reference...
[u/mrichter/AliRoot.git] / STEER / AliQADataMakerSteer.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 #include <TKey.h>
19 #include <TFile.h>
20 #include <TFileMerger.h>
21 #include <TPluginManager.h>
22 #include <TROOT.h>
23 #include <TString.h>
24 #include <TSystem.h>
25
26 #include "AliCDBManager.h"
27 #include "AliCDBEntry.h"
28 #include "AliCDBId.h"
29 #include "AliCDBMetaData.h"
30 #include "AliESDEvent.h"
31 #include "AliHeader.h"
32 #include "AliLog.h"
33 #include "AliModule.h"
34 #include "AliQA.h"
35 #include "AliQADataMaker.h"
36 #include "AliQADataMakerSteer.h" 
37 #include "AliRawReaderDate.h"
38 #include "AliRawReaderFile.h"
39 #include "AliRawReaderRoot.h"
40 #include "AliRun.h"
41 #include "AliRunLoader.h"
42
43 ClassImp(AliQADataMakerSteer) 
44
45 //_____________________________________________________________________________
46 AliQADataMakerSteer::AliQADataMakerSteer(const char* gAliceFilename, const char * name, const char * title) :
47         TNamed(name, title), 
48         fCycleSame(kFALSE),
49     fDetectors("ALL"), 
50         fESD(NULL), 
51         fESDTree(NULL),
52         fFirst(kTRUE),  
53         fGAliceFileName(gAliceFilename), 
54         fRunNumber(0), 
55         fNumberOfEvents(999999), 
56         fRawReader(NULL), 
57         fRawReaderDelete(kTRUE), 
58         fRunLoader(NULL)  
59 {
60         // default ctor
61         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
62                 if (IsSelected(AliQA::GetDetName(iDet))) {
63                         fLoader[iDet]      = NULL ;
64                         fQADataMaker[iDet] = NULL ;
65                         fQACycles[iDet]    = 999999 ;
66                 }
67         }       
68 }
69
70 //_____________________________________________________________________________
71 AliQADataMakerSteer::AliQADataMakerSteer(const AliQADataMakerSteer & qas) : 
72         TNamed(qas), 
73         fCycleSame(kFALSE),
74     fDetectors(qas.fDetectors), 
75         fESD(NULL), 
76         fESDTree(NULL), 
77         fFirst(qas.fFirst),  
78         fGAliceFileName(qas.fGAliceFileName), 
79         fRunNumber(qas.fRunNumber), 
80         fNumberOfEvents(qas.fNumberOfEvents), 
81         fRawReader(NULL), 
82         fRawReaderDelete(kTRUE), 
83         fRunLoader(NULL)  
84 {
85         // cpy ctor
86         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
87                 fLoader[iDet]      = qas.fLoader[iDet] ;
88                 fQADataMaker[iDet] = qas.fQADataMaker[iDet] ;
89                 fQACycles[iDet]    = qas.fQACycles[iDet] ;      
90         }
91 }
92
93 //_____________________________________________________________________________
94 AliQADataMakerSteer & AliQADataMakerSteer::operator = (const AliQADataMakerSteer & qas) 
95 {
96         // assignment operator
97   this->~AliQADataMakerSteer() ;
98   new(this) AliQADataMakerSteer(qas) ;
99   return *this ;
100 }
101
102 //_____________________________________________________________________________
103 AliQADataMakerSteer::~AliQADataMakerSteer() 
104 {
105         // dtor
106   for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
107           if (IsSelected(AliQA::GetDetName(iDet))) {
108                   fLoader[iDet] = NULL;
109                   if (fQADataMaker[iDet]) {
110                           (fQADataMaker[iDet])->Finish() ; 
111                           delete fQADataMaker[iDet] ;
112                           fQADataMaker[iDet] = NULL ;
113                   }
114           }
115   }
116
117   if (fRawReaderDelete) { 
118         fRunLoader = NULL ;
119         delete fRawReader ;
120         fRawReader = NULL ;
121   }
122 }
123
124 //_____________________________________________________________________________
125 Bool_t AliQADataMakerSteer::DoIt(const AliQA::TASKINDEX taskIndex)
126 {
127         // Runs all the QA data Maker for every detector
128         Bool_t rv = kFALSE ;
129         
130     // Fill QA data in event loop 
131         for (UInt_t iEvent = 0 ; iEvent < fNumberOfEvents ; iEvent++) {
132                 // Get the event
133                 AliDebug(1, Form("processing event %d", iEvent));
134                 if ( taskIndex == AliQA::kRAWS ) {
135                         if ( !fRawReader->NextEvent() )
136                                 break ;
137                 } else if ( taskIndex == AliQA::kESDS ) {
138                         if ( fESDTree->GetEntry(iEvent) == 0 )
139                                 break ;
140                 } else {
141                         if ( fRunLoader->GetEvent(iEvent) != 0 )
142                                 break ;
143                 }
144                 // loop over detectors
145                 TObjArray* detArray = NULL ; 
146                 if (fRunLoader) // check if RunLoader exists 
147                         if ( fRunLoader->GetAliRun() ) // check if AliRun exists in gAlice.root
148                                 detArray = fRunLoader->GetAliRun()->Detectors() ;
149                 for (UInt_t iDet = 0 ; iDet < fgkNDetectors ; iDet++) {
150                         if (detArray) {
151                                 AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQA::GetDetName(iDet))) ;
152                                 if (!det || !det->IsActive()) 
153                                         continue ;
154                         }
155                         if (!IsSelected(AliQA::GetDetName(iDet)))
156                                 continue ;
157                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
158                         if (!qadm) {
159                                 rv = kFALSE ;
160                         } else {
161                                 if ( qadm->IsCycleDone() ) {
162                                         qadm->EndOfCycle(AliQA::kRAWS) ;
163                                         qadm->StartOfCycle(AliQA::kRAWS) ;
164                                 }
165                                 TTree * data ; 
166                                 switch (taskIndex) {
167                                         case AliQA::kRAWS :
168                                                 qadm->Exec(taskIndex, fRawReader) ; 
169                                                 break ; 
170                                         case AliQA::kHITS :
171                                                 GetLoader(iDet)->LoadHits() ; 
172                                                 data = GetLoader(iDet)->TreeH() ; 
173                                                 if ( ! data ) {
174                                                         AliWarning(Form(" Hit Tree not found for  %s", AliQA::GetDetName(iDet))) ; 
175                                                 } else {
176                                                         qadm->Exec(taskIndex, data) ;
177                                                 } 
178                                                 break ;
179                                                 case AliQA::kSDIGITS :
180                                                 GetLoader(iDet)->LoadSDigits() ; 
181                                                 data = GetLoader(iDet)->TreeS() ; 
182                                                 if ( ! data ) {
183                                                         AliWarning(Form(" SDigit Tree not found for  %s", AliQA::GetDetName(iDet))) ; 
184                                                 } else {
185                                                         qadm->Exec(taskIndex, data) ; 
186                                                 }
187                                                 break; 
188                                                 case AliQA::kDIGITS :
189                                                 GetLoader(iDet)->LoadDigits() ; 
190                                                 data = GetLoader(iDet)->TreeD() ; 
191                                                 if ( ! data ) {
192                                                         AliWarning(Form(" Digit Tree not found for  %s", AliQA::GetDetName(iDet))) ; 
193                                                 } else {
194                                                         qadm->Exec(taskIndex, data) ;
195                                                 }
196                                                 break; 
197                                                 case AliQA::kRECPOINTS :
198                                                 GetLoader(iDet)->LoadRecPoints() ; 
199                                                 data = GetLoader(iDet)->TreeR() ; 
200                                                 if (!data) {
201                                                         AliWarning(Form("RecPoints not found for %s", AliQA::GetDetName(iDet))) ; 
202                                                 } else {
203                                                         qadm->Exec(taskIndex, data) ; 
204                                                 }
205                                                 break; 
206                                                 case AliQA::kTRACKSEGMENTS :
207                                                 break; 
208                                                 case AliQA::kRECPARTICLES :
209                                                 break; 
210                                                 case AliQA::kESDS :
211                                                 qadm->Exec(taskIndex, fESD) ;
212                                                 break; 
213                                                 case AliQA::kNTASKINDEX :
214                                                 break; 
215                                 } //task switch
216                                 qadm->Increment() ; 
217                         } //data maker exist
218                 } // detector loop
219         } // event loop 
220         // Save QA data for all detectors
221         rv = Finish(taskIndex) ;
222         return rv ; 
223 }
224
225 //_____________________________________________________________________________
226 Bool_t AliQADataMakerSteer::Finish(const AliQA::TASKINDEX taskIndex) 
227 {
228         // write output to file for all detectors
229         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
230                 if (IsSelected(AliQA::GetDetName(iDet))) {
231                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
232                         if (qadm) {
233                                 qadm->EndOfCycle(taskIndex) ; 
234                         }
235                 }
236         }
237         return kTRUE ; 
238 }
239
240 //_____________________________________________________________________________
241 TList * AliQADataMakerSteer::GetFromOCDB(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task) const 
242 {
243         // Retrieve the list of QA data for a given detector and a given task 
244         TList * rv = NULL ;
245         AliCDBManager* man = AliCDBManager::Instance() ; 
246         man->SetDefaultStorage("local://TestCDB")  ; 
247         char detOCDBDir[20] ; 
248         sprintf(detOCDBDir, "QA/Ref/%s", AliQA::GetDetName((Int_t)det)) ; 
249         AliInfo(Form("Retrieving reference data from local://TestCDB/%s %s", detOCDBDir, AliQA::GetTaskName(task).Data())) ; 
250         AliCDBEntry* entry = man->Get(detOCDBDir,0) ;
251         TList * listDetQAD = dynamic_cast<TList *>(entry->GetObject()) ;
252         if ( listDetQAD ) 
253                 rv = dynamic_cast<TList *>(listDetQAD->FindObject(AliQA::GetTaskName(task))) ; 
254
255         return rv ; 
256 }
257
258 //_____________________________________________________________________________
259 AliLoader * AliQADataMakerSteer::GetLoader(Int_t iDet)
260 {
261         // get the loader for a detector
262         
263         TString detName = AliQA::GetDetName(iDet) ;
264     fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
265         if (fLoader[iDet]) 
266                 return fLoader[iDet] ;
267         
268         // load the QA data maker object
269         TPluginManager* pluginManager = gROOT->GetPluginManager() ;
270         TString loaderName = "Ali" + detName + "Loader" ;
271
272         AliLoader * loader = NULL ;
273         // first check if a plugin is defined for the quality assurance data maker
274         TPluginHandler* pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
275         // if not, add a plugin for it
276         if (!pluginHandler) {
277                 AliDebug(1, Form("defining plugin for %s", loaderName.Data())) ;
278                 TString libs = gSystem->GetLibraries() ;
279                 if (libs.Contains("lib" + detName + "base.so") || (gSystem->Load("lib" + detName + "base.so") >= 0)) {
280                         pluginManager->AddHandler("AliQADataMaker", detName, loaderName, detName + "loader", loaderName + "()") ;
281                 } else {
282                         pluginManager->AddHandler("AliLoader", detName, loaderName, detName, loaderName + "()") ;
283                 }
284                 pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
285         }
286         if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
287                 loader = (AliLoader *) pluginHandler->ExecPlugin(0) ;
288         }
289         if (loader) 
290                 fLoader[iDet] = loader ;
291         return loader ;
292 }
293
294 //_____________________________________________________________________________
295 AliQADataMaker * AliQADataMakerSteer::GetQADataMaker(Int_t iDet)
296 {
297         // get the quality assurance data maker for a detector
298         
299         if (fQADataMaker[iDet]) 
300                 return fQADataMaker[iDet] ;
301         
302         AliQADataMaker * qadm = NULL ;
303         
304         if (fFirst) {
305                 // load the QA data maker object
306                 TPluginManager* pluginManager = gROOT->GetPluginManager() ;
307                 TString detName = AliQA::GetDetName(iDet) ;
308                 TString qadmName = "Ali" + detName + "QADataMaker" ;
309
310                 // first check if a plugin is defined for the quality assurance data maker
311                 TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
312                 // if not, add a plugin for it
313                 if (!pluginHandler) {
314                         AliDebug(1, Form("defining plugin for %s", qadmName.Data())) ;
315                         TString libs = gSystem->GetLibraries() ;
316                         if (libs.Contains("lib" + detName + "base.so") || (gSystem->Load("lib" + detName + "base.so") >= 0)) {
317                                 pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName + "qadm", qadmName + "()") ;
318                         } else {
319                                 pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName, qadmName + "()") ;
320                         }
321                         pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
322                 }
323                 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
324                         qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0) ;
325                 }
326                 if (qadm) 
327                         fQADataMaker[iDet] = qadm ;
328         }
329         return qadm ;
330 }
331
332 //_____________________________________________________________________________
333 Bool_t AliQADataMakerSteer::Init(const AliQA::TASKINDEX taskIndex, const  char * input )
334 {
335         // Initialize the event source and QA data makers
336         
337         if (taskIndex == AliQA::kRAWS) { 
338                 if (!fRawReader) {
339                         TString fileName(input);
340                         if (fileName.EndsWith("/")) {
341                                 fRawReader = new AliRawReaderFile(fileName);
342                         } else if (fileName.EndsWith(".root")) {
343                                 fRawReader = new AliRawReaderRoot(fileName);
344                         } else if (!fileName.IsNull()) {
345                                 fRawReader = new AliRawReaderDate(fileName);
346                                 fRawReader->SelectEvents(7);
347                         }
348                 }
349             if ( ! fRawReader ) 
350                         return kFALSE ; 
351                 fRawReader->NextEvent() ; 
352                 fRunNumber = fRawReader->GetRunNumber() ; 
353                 fRawReader->RewindEvents();
354                 fNumberOfEvents = 999999 ;
355         } else if (taskIndex == AliQA::kESDS) {
356                 if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
357                         TFile * esdFile = TFile::Open("AliESDs.root") ;
358                         fESDTree = dynamic_cast<TTree *> (esdFile->Get("esdTree")) ; 
359                         fESD     = new AliESDEvent() ;
360                         fESD->ReadFromTree(fESDTree) ;
361                         fESDTree->GetEntry(0) ; 
362                         fRunNumber = fESD->GetRunNumber() ; 
363                         fNumberOfEvents = fESDTree->GetEntries() ;
364                 } else {
365                         AliError("AliESDs.root not found") ; 
366                         return kFALSE ; 
367                 }                       
368         } else {
369                 if ( !InitRunLoader() ) { 
370                         AliWarning("No Run Loader not found") ; 
371                 } else {
372                         fNumberOfEvents = fRunLoader->GetNumberOfEvents() ;
373                 }
374         }
375                 // Initialize all QA data makers for all detectors
376         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
377                 if (IsSelected(AliQA::GetDetName(iDet))) {
378                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
379                         if (!qadm) {
380                                 AliWarning(Form("AliQADataMaker not found for %s", AliQA::GetDetName(iDet))) ; 
381                         } else {
382                                 AliInfo(Form("Data Maker found for %s", qadm->GetName())) ; 
383                                 qadm->Init(taskIndex, fRunNumber, GetQACycles(iDet)) ;
384                                 qadm->StartOfCycle(taskIndex, fCycleSame) ;
385                         }
386                 }
387         } 
388         fFirst = kFALSE ;
389         return kTRUE ; 
390 }
391
392 //_____________________________________________________________________________
393 Bool_t AliQADataMakerSteer::IsSelected(const char * det) 
394 {
395         // check whether detName is contained in detectors
396         // if yes, it is removed from detectors
397         
398         const TString detName(det) ;
399         // check if all detectors are selected
400         if ((fDetectors.CompareTo("ALL") == 0) ||
401                 fDetectors.BeginsWith("ALL ") ||
402                 fDetectors.EndsWith(" ALL") ||
403                 fDetectors.Contains(" ALL ")) {
404                 fDetectors = "ALL";
405                 return kTRUE;
406         }
407         
408         // search for the given detector
409         Bool_t rv = kFALSE;
410         if ((fDetectors.CompareTo(detName) == 0) ||
411                 fDetectors.BeginsWith(detName+" ") ||
412                 fDetectors.EndsWith(" "+detName) ||
413                 fDetectors.Contains(" "+detName+" ")) {
414 //              fDetectors.ReplaceAll(detName, "");
415                 rv = kTRUE;
416         }
417         
418         // clean up the detectors string
419 //      while (fDetectors.Contains("  ")) 
420 //              fDetectors.ReplaceAll("  ", " ");
421 //      while (fDetectors.BeginsWith(" ")) 
422 //              fDetectors.Remove(0, 1);
423 //      while (fDetectors.EndsWith(" ")) 
424 //              fDetectors.Remove(fDetectors.Length()-1, 1);
425         
426         return rv ;
427 }
428
429 //_____________________________________________________________________________
430 Bool_t AliQADataMakerSteer::InitRunLoader()
431 {
432         // get or create the run loader
433         if (fRunLoader) {
434                 fCycleSame = kTRUE ; 
435                 return kTRUE ;
436         } 
437                 
438         if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
439     // load all base libraries to get the loader classes
440                 TString libs = gSystem->GetLibraries() ;
441                 for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
442                         if (!IsSelected(AliQA::GetDetName(iDet))) 
443                                 continue ; 
444                         TString detName = AliQA::GetDetName(iDet) ;
445                         if (detName == "HLT") 
446                                 continue;
447                         if (libs.Contains("lib" + detName + "base.so")) 
448                                 continue;
449                         gSystem->Load("lib" + detName + "base.so");
450                 }
451                 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
452                 if (!fRunLoader) {
453                         AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
454                         return kFALSE;
455                 }
456                 fRunLoader->CdGAFile();
457                 if (fRunLoader->LoadgAlice() == 0) {
458                         gAlice = fRunLoader->GetAliRun();
459                 }
460
461                 if (!gAlice) {
462                         AliError(Form("no gAlice object found in file %s", fGAliceFileName.Data()));
463                         return kFALSE;
464                 }
465
466         } else {               // galice.root does not exist
467                 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
468                 return kFALSE;
469     }
470
471   return kTRUE;
472 }
473
474 //_____________________________________________________________________________
475 Bool_t AliQADataMakerSteer::Merge(const Int_t runNumber) const
476 {
477         // Merge all the cycles from all detectors in one single file per run
478         char cmd[80] ;
479         if ( runNumber == -1 )
480                 sprintf(cmd, ".! ls *%s*.*.*.root > tempo.txt", AliQA::GetQADataFileName()) ; 
481         else 
482                 sprintf(cmd, ".! ls *%s*.%d.*.root > tempo.txt", AliQA::GetQADataFileName(), runNumber) ; 
483         gROOT->ProcessLine(cmd) ;
484         ifstream in("tempo.txt") ; 
485         const Int_t runMax = 10 ;  
486         TString file[AliQA::kNDET*runMax] ;
487         Int_t run[AliQA::kNDET*runMax] ;
488         
489         Int_t index = 0 ; 
490         while ( 1 ) {
491                 in >> file[index] ; 
492                 if ( !in.good() ) 
493                         break ; 
494                 index++ ;
495         }
496         
497         if ( index == 0 ) { 
498                 AliError(Form("run number %d not found", runNumber)) ; 
499                 return kFALSE ; 
500         }
501         
502         Int_t previousRun = -1 ;
503         Int_t runIndex = 0 ;  
504         char stmp[10] ; 
505         sprintf(stmp, ".%s.", AliQA::GetQADataFileName()) ; 
506         for (Int_t ifile = 0 ; ifile < index-1 ; ifile++) {
507                 TString tmp(file[ifile]) ; 
508                 tmp.ReplaceAll(".root", "") ; 
509                 TString det = tmp(0, tmp.Index(".")) ; 
510                 tmp.Remove(0, tmp.Index(stmp)+4) ; 
511                 TString ttmp = tmp(0, tmp.Index(".")) ; 
512                 Int_t newRun = ttmp.Atoi() ;
513                 if (newRun != previousRun) {
514                         run[runIndex] = newRun ; 
515                         previousRun = newRun ; 
516                         runIndex++ ; 
517                 }
518                 ttmp = tmp(tmp.Index("."), tmp.Length()) ; 
519                 Int_t cycle = ttmp.Atoi() ;  
520                 AliInfo(Form("%s : det = %s run = %d cycle = %d \n", file[ifile].Data(), det.Data(), newRun, cycle)) ; 
521         }
522         for (Int_t irun = 0 ; irun < runIndex ; irun++) {
523                 TFileMerger merger ; 
524                 char outFileName[20] ; 
525                 sprintf(outFileName, "Merged.%s.%d.root", AliQA::GetQADataFileName(), runIndex-1) ; 
526                 merger.OutputFile(outFileName) ; 
527                 for (Int_t ifile = 0 ; ifile < index-1 ; ifile++) {
528                         char pattern[100] ; 
529                         sprintf(pattern, "%s.%d.", AliQA::GetQADataFileName(), runIndex-1) ; 
530                         TString tmp(file[ifile]) ; 
531                         if (tmp.Contains(pattern))
532                                 merger.AddFile(tmp) ; 
533                 }
534                 merger.Merge() ; 
535         }
536         
537         return kTRUE ; 
538 }
539
540 //_____________________________________________________________________________
541 void AliQADataMakerSteer::Reset()
542 {
543         // Reset the default data members
544         for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
545                 if (IsSelected(AliQA::GetDetName(iDet))) {
546                         fLoader[iDet] = NULL;
547                         if (fQADataMaker[iDet]) {
548                                 (fQADataMaker[iDet])->Reset() ; 
549                                 //delete fQADataMaker[iDet] ;
550                                 //fQADataMaker[iDet] = NULL ;
551                         }
552                 }
553         }
554
555         if (fRawReaderDelete) { 
556                 delete fRawReader ;
557                 fRawReader      = NULL ;
558         }
559
560         fCycleSame      = kFALSE ; 
561         fESD            = NULL ; 
562         fESDTree        = NULL ; 
563         fFirst          = kTRUE ;   
564         fNumberOfEvents = 999999 ;  
565 }
566
567 //_____________________________________________________________________________
568 Bool_t AliQADataMakerSteer::Run(const char * detectors, AliRawReader * rawReader) 
569 {
570         //Runs all the QA data Maker for Raws only
571         fRawReader       = rawReader ;          
572         fRawReaderDelete = kFALSE ; 
573         fCycleSame       = kTRUE ; 
574         fDetectors       = detectors ; 
575
576         // Initialize all QA data makers for all detectors
577         for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
578                 if (IsSelected(AliQA::GetDetName(iDet))) {
579                         AliQADataMaker * qadm = GetQADataMaker(iDet) ;
580                         if (!qadm) {
581                                 AliWarning(Form("AliQADataMaker not found for %s", AliQA::GetDetName(iDet))) ; 
582                         } else {
583                                 AliInfo(Form("Data Maker found for %s", qadm->GetName())) ; 
584                                 qadm->Init(AliQA::kRAWS, fRunNumber, GetQACycles(iDet)) ;
585                                 qadm->StartOfCycle(AliQA::kRAWS, fCycleSame) ;
586                         }
587                 }
588         } 
589         fFirst = kFALSE ;
590                 
591         return DoIt(AliQA::kRAWS) ; 
592 }
593
594 //_____________________________________________________________________________
595 Bool_t AliQADataMakerSteer::Run(const char * detectors, const AliQA::TASKINDEX taskIndex, const  char * fileName )
596 {
597         // Runs all the QA data Maker for every detector
598
599         Bool_t rv  = kFALSE ;
600         fDetectors = detectors ; 
601         
602         if ( !Init(taskIndex, fileName) ) 
603                 return kFALSE ; 
604
605         rv = DoIt(taskIndex) ;
606         
607         return rv ;   
608
609 }
610
611 //_____________________________________________________________________________
612 Bool_t AliQADataMakerSteer::Save2OCDB(const Int_t runNumber, const Int_t cycleNumber, const char * detectors) const
613 {
614         // take the locasl QA data merge into a single file and save in OCDB 
615         Bool_t rv = kTRUE ; 
616         TString tmp(AliQA::GetQARefStorage()) ; 
617         if ( tmp.IsNull() ) { 
618                 AliError("No storage defined, use AliQA::SetQARefStorage") ; 
619                 return kFALSE ; 
620         }
621         if ( !(tmp.Contains(AliQA::GetLabLocalOCDB()) || tmp.Contains(AliQA::GetLabAliEnOCDB())) ) {
622                 AliError(Form("%s is a wrong storage, use %s or %s", AliQA::GetQARefStorage(), AliQA::GetLabLocalOCDB().Data(), AliQA::GetLabAliEnOCDB().Data())) ; 
623                 return kFALSE ; 
624         }
625         TString sdet(detectors) ; 
626         sdet.ToUpper() ;
627         TFile * inputFile ; 
628         if ( sdet.Contains("ALL") ) {
629                 rv = Merge(runNumber) ; 
630                 if ( ! rv )
631                         return kFALSE ; 
632                 char inputFileName[20] ; 
633                 sprintf(inputFileName, "Merged.%s.%d.root", AliQA::GetQADataFileName(), runNumber) ; 
634                 inputFile = TFile::Open(inputFileName) ; 
635                 rv = SaveIt2OCDB(inputFile) ; 
636         } else {
637                 for (Int_t index = 0; index < AliQA::kNDET; index++) {
638                         if (sdet.Contains(AliQA::GetDetName(index))) {
639                                 char inputFileName[20] ; 
640                                 sprintf(inputFileName, "%s.%s.%d.%d.root", AliQA::GetDetName(index), AliQA::GetQADataFileName(), runNumber, cycleNumber) ; 
641                                 inputFile = TFile::Open(inputFileName) ;                        
642                                 rv *= SaveIt2OCDB(inputFile) ; 
643                         }
644                 }
645         }
646         return rv ; 
647 }
648
649 //_____________________________________________________________________________
650 Bool_t AliQADataMakerSteer::SaveIt2OCDB(TFile * inputFile) const
651 {
652         // reads the TH1 from file and adds it to appropriate list before saving to OCDB
653         Bool_t rv = kTRUE ;
654         AliInfo(Form("Saving TH1s in %s to %s", inputFile->GetName(), AliQA::GetQARefStorage())) ; 
655         AliCDBManager* man = AliCDBManager::Instance() ; 
656         man->SetDefaultStorage(AliQA::GetQARefStorage()) ; 
657
658         for ( Int_t detIndex = 0 ; detIndex < AliQA::kNDET ; detIndex++) {
659                 TDirectory * detDir = inputFile->GetDirectory(AliQA::GetDetName(detIndex)) ; 
660                 if ( detDir ) {
661                         AliInfo(Form("Entering %s", detDir->GetName())) ;
662                         char detOCDBDir[20] ; 
663                         sprintf(detOCDBDir, "QA/Ref/%s", AliQA::GetDetName(detIndex)) ; 
664                         AliCDBId idr(detOCDBDir,0,999999999)  ;
665                         TList * listDetQAD = new TList() ;
666                         char listName[20] ; 
667                         sprintf(listName, "%s QA data Reference", AliQA::GetDetName(detIndex)) ; 
668                         listDetQAD->SetName(listName) ; 
669                         TList * taskList = detDir->GetListOfKeys() ; 
670                         TIter nextTask(taskList) ; 
671                         TKey * taskKey ; 
672                         while ( (taskKey = dynamic_cast<TKey*>(nextTask())) ) {
673                                 TDirectory * taskDir = detDir->GetDirectory(taskKey->GetName()) ; 
674                                 AliInfo(Form("Saving %s", taskDir->GetName())) ; 
675                                 TList * listTaskQAD = new TList() ; 
676                                 listTaskQAD->SetName(taskKey->GetName()) ;
677                                 listDetQAD->Add(listTaskQAD) ; 
678                                 TList * histList = taskDir->GetListOfKeys() ; 
679                                 TIter nextHist(histList) ; 
680                                 TKey * histKey ; 
681                                 while ( (histKey = dynamic_cast<TKey*>(nextHist())) ) {
682                                         TObject * odata = taskDir->Get(histKey->GetName()) ; 
683                                         if ( odata->IsA()->InheritsFrom("TH1") ) {
684                                                 AliInfo(Form("Adding %s", histKey->GetName())) ;
685                                                 TH1 * hdata = static_cast<TH1*>(odata) ; 
686                                                 listTaskQAD->Add(hdata) ; 
687                                         }
688                                 }
689                         }
690                         AliCDBMetaData mdr ;
691                         man->Put(listDetQAD, idr, &mdr) ;
692                 }
693         }
694         return rv ; 
695 }