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