]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - STEER/AliQAManager.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Added protections to avoid crashes with Print() when ESDEvent is fetched from the...
[u/mrichter/AliRoot.git] / STEER / AliQAManager.cxx
... / ...
CommitLineData
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
70ClassImp(AliQAManager)
71AliQAManager* AliQAManager::fgQAInstance = 0x0;
72
73//_____________________________________________________________________________
74AliQAManager::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//_____________________________________________________________________________
110AliQAManager::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//_____________________________________________________________________________
146AliQAManager::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//_____________________________________________________________________________
180AliQAManager & AliQAManager::operator = (const AliQAManager & qas)
181{
182 // assignment operator
183 this->~AliQAManager() ;
184 new(this) AliQAManager(qas) ;
185 return *this ;
186}
187
188//_____________________________________________________________________________
189AliQAManager::~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//_____________________________________________________________________________
208Bool_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//_____________________________________________________________________________
331Bool_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//_____________________________________________________________________________
348TObjArray * 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//_____________________________________________________________________________
373TCanvas ** 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//_____________________________________________________________________________
384AliLoader * 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//_____________________________________________________________________________
423AliQAv1 * 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//_____________________________________________________________________________
447AliQADataMaker * 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) { //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(), "Rec") == 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
483 // load the QA data maker object
484 TPluginManager* pluginManager = gROOT->GetPluginManager() ;
485 TString detName = AliQAv1::GetDetName(iDet) ;
486 TString qadmName = "Ali" + detName + "QADataMaker" + GetMode() ;
487
488 // first check if a plugin is defined for the quality assurance data maker
489 TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
490 // if not, add a plugin for it
491 if (!pluginHandler) {
492 AliDebug(AliQAv1::GetQADebugLevel(), Form("defining plugin for %s", qadmName.Data())) ;
493 TString libs = gSystem->GetLibraries() ;
494 TString temp(GetMode()) ;
495 temp.ToLower() ;
496 if (libs.Contains("lib" + detName + GetMode() + ".so") || (gSystem->Load("lib" + detName + temp.Data() + ".so") >= 0)) {
497 pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName + "qadm", qadmName + "()") ;
498 } else {
499 pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName, qadmName + "()") ;
500 }
501 pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
502 }
503 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
504 qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0) ;
505 }
506 if (qadm) {
507 qadm->SetName(AliQAv1::GetDetName(iDet));
508 qadm->SetUniqueID(iDet);
509 fQADataMaker[iDet] = qadm ;
510 qadm->SetEventSpecie(fEventSpecie) ;
511 if ( qadm->GetRecoParam() )
512 if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
513 qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
514 }
515 }
516 return qadm ;
517}
518
519//_____________________________________________________________________________
520void AliQAManager::EndOfCycle(TObjArray * detArray)
521{
522 // End of cycle QADataMakers
523
524 AliQAChecker::Instance()->SetRunNumber(fRunNumber) ;
525 TCanvas fakeCanvas ;
526
527 fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ;
528 for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
529 if (IsSelected(AliQAv1::GetDetName(iDet))) {
530 AliQADataMaker * qadm = GetQADataMaker(iDet) ;
531 if (!qadm)
532 continue ;
533 // skip non active detectors
534 if (detArray) {
535 AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQAv1::GetDetName(iDet))) ;
536 if (!det || !det->IsActive())
537 continue ;
538 }
539 AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(iDet) ;
540 if (qac)
541 qac->SetPrintImage(fPrintImage) ;
542 for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
543 if ( fTasks.Contains(Form("%d", taskIndex)) )
544 qadm->EndOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex))) ;
545 }
546 qadm->Finish();
547 }
548 }
549 if (fPrintImage)
550 fakeCanvas.Print(Form("%s%s%d.%s]", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps");
551}
552
553//_____________________________________________________________________________
554void AliQAManager::EndOfCycle(TString detectors)
555{
556 // End of cycle QADataMakers
557
558 AliQAChecker::Instance()->SetRunNumber(fRunNumber) ;
559 TCanvas fakeCanvas ;
560 if (fPrintImage)
561 fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ;
562 for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
563 if (IsSelected(AliQAv1::GetDetName(iDet))) {
564 AliQADataMaker * qadm = GetQADataMaker(iDet) ;
565 if (!qadm)
566 continue ;
567 // skip non active detectors
568 if (!detectors.Contains(AliQAv1::GetDetName(iDet)))
569 continue ;
570 AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(iDet) ;
571 if (qac)
572 qac->SetPrintImage(fPrintImage) ;
573 for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
574 if ( fTasks.Contains(Form("%d", taskIndex)) )
575 qadm->EndOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex))) ;
576 }
577 qadm->Finish();
578 }
579 }
580 if (fPrintImage)
581 fakeCanvas.Print(Form("%s%s%d.%s]", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps");
582}
583
584//_____________________________________________________________________________
585void AliQAManager::Increment(const AliQAv1::TASKINDEX_t taskIndex)
586{
587 // Increments the cycle counter for all QA Data Makers
588 static AliQAv1::TASKINDEX_t currentTask = AliQAv1::kNTASKINDEX ;
589 if (currentTask == taskIndex)
590 return ;
591 else
592 currentTask = taskIndex ;
593 for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
594 if (IsSelected(AliQAv1::GetDetName(iDet))) {
595 AliQADataMaker * qadm = GetQADataMaker(iDet) ;
596 if (qadm)
597 qadm->Increment() ;
598 }
599 }
600}
601
602//_____________________________________________________________________________
603Bool_t AliQAManager::InitQA(const AliQAv1::TASKINDEX_t taskIndex, const Char_t * input )
604{
605 // Initialize the event source and QA data makers
606
607 fTasks += Form("%d", taskIndex) ;
608
609 if (taskIndex == AliQAv1::kRAWS) {
610 if (!fRawReader) {
611 fRawReader = AliRawReader::Create(input);
612 }
613 if ( ! fRawReader )
614 return kFALSE ;
615 fRawReaderDelete = kTRUE ;
616 fRawReader->NextEvent() ;
617 fRunNumber = fRawReader->GetRunNumber() ;
618 SetRun(fRunNumber) ;
619 fRawReader->RewindEvents();
620 fNumberOfEvents = 999999 ;
621 if ( fMaxEvents < 0 )
622 fMaxEvents = fNumberOfEvents ;
623 } else if (taskIndex == AliQAv1::kESDS) {
624 fTasks = AliQAv1::GetTaskName(AliQAv1::kESDS) ;
625 if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
626 TFile * esdFile = TFile::Open("AliESDs.root") ;
627 fESDTree = static_cast<TTree *> (esdFile->Get("esdTree")) ;
628 if ( !fESDTree ) {
629 AliError("esdTree not found") ;
630 return kFALSE ;
631 } else {
632 fESD = new AliESDEvent() ;
633 fESD->ReadFromTree(fESDTree) ;
634 fESDTree->GetEntry(0) ;
635 fRunNumber = fESD->GetRunNumber() ;
636 fNumberOfEvents = fESDTree->GetEntries() ;
637 if ( fMaxEvents < 0 )
638 fMaxEvents = fNumberOfEvents ;
639 }
640 } else {
641 AliError("AliESDs.root not found") ;
642 return kFALSE ;
643 }
644 } else {
645 if ( !InitRunLoader() ) {
646 AliWarning("No Run Loader not found") ;
647 } else {
648 fNumberOfEvents = fRunLoader->GetNumberOfEvents() ;
649 if ( fMaxEvents < 0 )
650 fMaxEvents = fNumberOfEvents ;
651 }
652 }
653
654 // Get Detectors
655 TObjArray* detArray = NULL ;
656 if (fRunLoader) // check if RunLoader exists
657 if ( fRunLoader->GetAliRun() ) { // check if AliRun exists in gAlice.root
658 detArray = fRunLoader->GetAliRun()->Detectors() ;
659 fRunNumber = fRunLoader->GetHeader()->GetRun() ;
660 }
661
662 // Initialize all QA data makers for all detectors
663 fRunNumber = AliCDBManager::Instance()->GetRun() ;
664 if ( ! AliGeomManager::GetGeometry() )
665 AliGeomManager::LoadGeometry() ;
666
667 InitQADataMaker(fRunNumber, detArray) ; //, fCycleSame, kTRUE, detArray) ;
668 if (fPrintImage) {
669 TCanvas fakeCanvas ;
670 TStopwatch timer ;
671 timer.Start() ;
672 while (timer.CpuTime()<5) {
673 timer.Continue();
674 gSystem->ProcessEvents();
675 }
676 fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ;
677 }
678 return kTRUE ;
679}
680
681//_____________________________________________________________________________
682void AliQAManager::InitQADataMaker(UInt_t run, TObjArray * detArray)
683{
684 // Initializes The QADataMaker for all active detectors and for all active tasks
685 fRunNumber = run ;
686 for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
687 if (IsSelected(AliQAv1::GetDetName(iDet))) {
688 AliQADataMaker * qadm = GetQADataMaker(iDet) ;
689 if (!qadm) {
690 AliError(Form("AliQADataMaker not found for %s", AliQAv1::GetDetName(iDet))) ;
691 fDetectorsW.ReplaceAll(AliQAv1::GetDetName(iDet), "") ;
692 } else {
693 if (fQAWriteExpert[iDet])
694 qadm->SetWriteExpert() ;
695 AliDebug(AliQAv1::GetQADebugLevel(), Form("Data Maker found for %s %d", qadm->GetName(), qadm->WriteExpert())) ;
696 // skip non active detectors
697 if (detArray) {
698 AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQAv1::GetDetName(iDet))) ;
699 if (!det || !det->IsActive())
700 continue ;
701 }
702 // Set default reco params
703 Bool_t sameCycle = kFALSE ;
704 for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
705 if ( fTasks.Contains(Form("%d", taskIndex)) ) {
706 qadm->Init(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), GetQACycles(qadm->GetUniqueID())) ;
707 qadm->StartOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), run, sameCycle) ;
708 sameCycle = kTRUE ;
709 }
710 }
711 }
712 }
713 }
714}
715
716
717//_____________________________________________________________________________
718Bool_t AliQAManager::InitRunLoader()
719{
720 // get or create the run loader
721 if (fRunLoader) {
722 fCycleSame = kTRUE ;
723 } else {
724 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
725 // load all base libraries to get the loader classes
726 TString libs = gSystem->GetLibraries() ;
727 for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
728 if (!IsSelected(AliQAv1::GetDetName(iDet)))
729 continue ;
730 TString detName = AliQAv1::GetDetName(iDet) ;
731 if (detName == "HLT")
732 continue;
733 if (libs.Contains("lib" + detName + "base.so"))
734 continue;
735 gSystem->Load("lib" + detName + "base.so");
736 }
737 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
738 if (!fRunLoader) {
739 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
740 return kFALSE;
741 }
742 fRunLoader->CdGAFile();
743 if (fRunLoader->LoadgAlice() == 0) {
744 gAlice = fRunLoader->GetAliRun();
745 }
746
747 if (!gAlice) {
748 AliError(Form("no gAlice object found in file %s", fGAliceFileName.Data()));
749 return kFALSE;
750 }
751
752 } else { // galice.root does not exist
753 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
754 return kFALSE;
755 }
756 }
757
758 if (!fRunNumber) {
759 fRunLoader->LoadHeader();
760 fRunNumber = fRunLoader->GetHeader()->GetRun() ;
761 }
762 return kTRUE;
763}
764
765//_____________________________________________________________________________
766Bool_t AliQAManager::IsSelected(const Char_t * det)
767{
768 // check whether detName is contained in detectors
769 // if yes, it is removed from detectors
770
771 Bool_t rv = kFALSE;
772 const TString detName(det) ;
773 // always activates Correlation
774 if ( detName.Contains(AliQAv1::GetDetName(AliQAv1::kCORR)) || detName.Contains(AliQAv1::GetDetName(AliQAv1::kGLOBAL))) {
775 rv = kTRUE ;
776 } else {
777 // check if all detectors are selected
778 if (fDetectors.Contains("ALL")) {
779 fDetectors = "ALL";
780 rv = kTRUE;
781 } else if ((fDetectors.CompareTo(detName) == 0) ||
782 fDetectors.BeginsWith(detName+" ") ||
783 fDetectors.EndsWith(" "+detName) ||
784 fDetectors.Contains(" "+detName+" ")) {
785 rv = kTRUE;
786 }
787 }
788 return rv ;
789}
790
791//_____________________________________________________________________________
792Bool_t AliQAManager::Merge(Int_t runNumber, const char *fileName) const
793{
794 // Merge data from all detectors from a given run in one single file
795 // Merge the QA results from all the data chunks in one run
796 // The 'fileName' is name of the output file with merged QA data
797 if ( runNumber == -1)
798 runNumber = fRunNumber ;
799 Bool_t rv = MergeData(runNumber,fileName) ;
800 //rv *= MergeResults(runNumber) ; // not needed for the time being
801 return rv ;
802}
803
804//______________________________________________________________________
805Bool_t AliQAManager::MergeXML(const Char_t * collectionFile, const Char_t * subFile, const Char_t * outFile)
806{
807 // merges files listed in a xml collection
808 // usage Merge(collection, outputFile))
809 // collection: is a xml collection
810
811 Bool_t rv = kFALSE ;
812
813 if ( strstr(collectionFile, ".xml") == 0 ) {
814 AliError("Input collection file must be an \".xml\" file\n") ;
815 return kFALSE ;
816 }
817
818 if ( !gGrid )
819 TGrid::Connect("alien://");
820 if ( !gGrid )
821 return kFALSE ;
822
823 // Open the file collection
824 AliInfoClass(Form("*** Create Collection ***\n*** Wk-Dir = |%s| \n*** Coll = |%s| \n",gSystem->WorkingDirectory(), collectionFile));
825
826 TGridCollection * collection = (TGridCollection*)gROOT->ProcessLine(Form("TAlienCollection::Open(\"%s\")",collectionFile));
827 TGridResult* result = collection->GetGridResult("", 0, 0);
828
829 Int_t index = 0 ;
830 const Char_t * turl ;
831 TFileMerger merger(kFALSE) ;
832 if (!outFile) {
833 TString tempo(collectionFile) ;
834 if ( subFile)
835 tempo.ReplaceAll(".xml", subFile) ;
836 else
837 tempo.ReplaceAll(".xml", "_Merged.root") ;
838 outFile = tempo.Data() ;
839 }
840 merger.OutputFile(outFile) ;
841
842 while ( (turl = result->GetKey(index, "turl")) ) {
843 Char_t * file ;
844 if ( subFile )
845 file = Form("%s#%s", turl, subFile) ;
846 else
847 file = Form("%s", turl) ;
848
849 AliDebug(AliQAv1::GetQADebugLevel(), Form("%s\n", file)) ;
850 merger.AddFile(file) ;
851 index++ ;
852 }
853
854 if (index)
855 merger.Merge() ;
856
857 AliDebug(AliQAv1::GetQADebugLevel(), Form("Files merged into %s\n", outFile)) ;
858
859 rv = kFALSE;
860 return rv ;
861}
862
863//_____________________________________________________________________________
864void AliQAManager::MergeCustom() const
865{
866 // Custom Merge of QA data from all detectors for all runs in one single file
867 // search all the run numbers
868 // search all the run numbers
869 gROOT->ProcessLine(".! ls *QA*.root > QAtempo.txt") ;
870 TString QAfile ;
871 FILE * QAfiles = fopen("QAtempo.txt", "r") ;
872 Int_t index = 0 ;
873 TList srunList ;
874 TIter nextRun(&srunList) ;
875 TObjString * srun = NULL ;
876 Int_t loRun = 999999999 ;
877 Int_t hiRun = 0 ;
878 while ( QAfile.Gets(QAfiles) ) {
879 Bool_t runExist = kFALSE ;
880 TString srunNew(QAfile(QAfile.Index("QA.")+3, QAfile.Index(".root")-(QAfile.Index("QA.")+3))) ;
881 Int_t cuRun = srunNew.Atoi() ;
882 if (cuRun < loRun)
883 loRun = cuRun ;
884 if (cuRun > hiRun)
885 hiRun = cuRun ;
886 while ( (srun = static_cast<TObjString *> (nextRun())) ) {
887 if ( cuRun == (srun->String()).Atoi() ) {
888 runExist = kTRUE ;
889 break ;
890 }
891 }
892 nextRun.Reset() ;
893 if ( ! runExist )
894 srunList.Add(new TObjString(srunNew.Data()));
895 }
896 nextRun.Reset() ;
897 Int_t runNumber = 0 ;
898 TFile mergedFile(Form("Merged.%s.Data.root", AliQAv1::GetQADataFileName()), "RECREATE") ;
899 TH1I * hisRun = new TH1I("hLMR", "List of merged runs", hiRun-loRun+10, loRun, hiRun+10) ;
900 // create the structure into the merged file
901 for (Int_t iDet = 0; iDet < AliQAv1::kNDET ; iDet++) {
902 TDirectory * detDir = mergedFile.mkdir(AliQAv1::GetDetName(iDet)) ;
903 for (Int_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
904 detDir->cd() ;
905 TDirectory * taskDir = gDirectory->mkdir(AliQAv1::GetTaskName(taskIndex)) ;
906 for (Int_t es = 0 ; es < AliRecoParam::kNSpecies ; es++) {
907 taskDir->cd() ;
908 TDirectory * esDir = gDirectory->mkdir(AliRecoParam::GetEventSpecieName(es)) ;
909 esDir->cd() ;
910 gDirectory->mkdir(AliQAv1::GetExpert()) ;
911 }
912 }
913 }
914 while ( (srun = static_cast<TObjString *> (nextRun())) ) {
915 runNumber = (srun->String()).Atoi() ;
916 hisRun->Fill(runNumber) ;
917 AliDebug(AliQAv1::GetQADebugLevel(), Form("Merging run number %d", runNumber)) ;
918 // search all QA files for runNumber in the current directory
919 Char_t * fileList[AliQAv1::kNDET] ;
920 index = 0 ;
921 for (Int_t iDet = 0; iDet < AliQAv1::kNDET ; iDet++) {
922 Char_t * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQAv1::GetDetName(iDet), AliQAv1::GetQADataFileName(), runNumber));
923 if (file)
924 fileList[index++] = file ;
925 }
926 if ( index == 0 ) {
927 AliError("No QA data file found\n") ;
928 return ;
929 }
930 for ( Int_t i = 0 ; i < index ; i++) {
931 TFile * inFile = TFile::Open(fileList[i]) ;
932 TList * listOfKeys =inFile->GetListOfKeys() ;
933 TIter nextkey(listOfKeys) ;
934 TObject * obj1 ;
935 TString dirName("") ;
936 while ( (obj1 = nextkey()) ) {
937 TDirectory * directoryDet = inFile->GetDirectory(obj1->GetName()) ;
938 if ( directoryDet ) {
939 AliDebug(AliQAv1::GetQADebugLevel(), Form("%s dir = %s", inFile->GetName(), directoryDet->GetName())) ;
940 dirName += Form("%s/", directoryDet->GetName() ) ;
941 directoryDet->cd() ;
942 TList * listOfTasks = directoryDet->GetListOfKeys() ;
943 TIter nextTask(listOfTasks) ;
944 TObject * obj2 ;
945 while ( (obj2 = nextTask()) ) {
946 TDirectory * directoryTask = directoryDet->GetDirectory(obj2->GetName()) ;
947 if ( directoryTask ) {
948 dirName += Form("%s", obj2->GetName()) ;
949 AliDebug(AliQAv1::GetQADebugLevel(), Form("%s", dirName.Data())) ;
950 directoryTask->cd() ;
951 TList * listOfEventSpecie = directoryTask->GetListOfKeys() ;
952 TIter nextEventSpecie(listOfEventSpecie) ;
953 TObject * obj3 ;
954 while ( (obj3 = nextEventSpecie()) ) {
955 TDirectory * directoryEventSpecie = directoryTask->GetDirectory(obj3->GetName()) ;
956 if ( directoryEventSpecie ) {
957 dirName += Form("/%s/", obj3->GetName()) ;
958 AliDebug(AliQAv1::GetQADebugLevel(), Form("%s\n", dirName.Data())) ;
959 directoryEventSpecie->cd() ;
960 // histograms are here
961 TDirectory * mergedDirectory = mergedFile.GetDirectory(dirName.Data()) ;
962 TList * listOfData = directoryEventSpecie->GetListOfKeys() ;
963 TIter nextData(listOfData) ;
964 TKey * key ;
965 while ( (key = static_cast<TKey *>(nextData())) ) {
966 TString className(key->GetClassName()) ;
967 if ( className.Contains("TH") || className.Contains("TProfile") ) {
968 TH1 * histIn = static_cast<TH1*> (key->ReadObj()) ;
969 TH1 * histOu = static_cast<TH1*> (mergedDirectory->FindObjectAny(histIn->GetName())) ;
970 AliDebug(AliQAv1::GetQADebugLevel(), Form("%s %x %x\n", key->GetName(), histIn, histOu)) ;
971 mergedDirectory->cd() ;
972 if ( ! histOu ) {
973 histIn->Write() ;
974 } else {
975 histOu->Add(histIn) ;
976 histOu->Write(histOu->GetName(), kOverwrite) ;
977 }
978 }
979 else if ( className.Contains("TDirectoryFile") ) {
980 TDirectory * dirExpert = directoryEventSpecie->GetDirectory(key->GetName()) ;
981 dirExpert->cd() ;
982 TDirectory * mergedDirectoryExpert = mergedDirectory->GetDirectory(dirExpert->GetName()) ;
983 TList * listOfExpertData = dirExpert->GetListOfKeys() ;
984 TIter nextExpertData(listOfExpertData) ;
985 TKey * keykey ;
986 while ( (keykey = static_cast<TKey *>(nextExpertData())) ) {
987 TString classNameExpert(keykey->GetClassName()) ;
988 if (classNameExpert.Contains("TH")) {
989 TH1 * histInExpert = static_cast<TH1*> (keykey->ReadObj()) ;
990 TH1 * histOuExpert = static_cast<TH1*> (mergedDirectory->FindObjectAny(histInExpert->GetName())) ;
991 mergedDirectoryExpert->cd() ;
992 if ( ! histOuExpert ) {
993 histInExpert->Write() ;
994 } else {
995 histOuExpert->Add(histInExpert) ;
996 histOuExpert->Write(histOuExpert->GetName(), kOverwrite) ;
997 }
998 }
999 }
1000 } else {
1001 AliError(Form("No merge done for this object %s in %s", key->GetName(), dirName.Data())) ;
1002 }
1003 }
1004 dirName.ReplaceAll(Form("/%s/",obj3->GetName()), "") ;
1005 }
1006 }
1007 dirName.ReplaceAll(obj2->GetName(), "") ;
1008 }
1009 }
1010 }
1011 }
1012 inFile->Close() ;
1013 }
1014 }
1015 mergedFile.cd() ;
1016 hisRun->Write() ;
1017 mergedFile.Close() ;
1018 srunList.Delete() ;
1019}
1020
1021//_____________________________________________________________________________
1022Bool_t AliQAManager::MergeData(const Int_t runNumber, const char *fileName) const
1023{
1024 // Merge QA data from all detectors for a given run in one single file
1025
1026 TFileMerger merger(kFALSE) ;
1027 TString outFileName = fileName;
1028 if (outFileName.IsNull()) outFileName.Form("Merged.%s.Data.root",AliQAv1::GetQADataFileName());
1029 merger.OutputFile(outFileName.Data()) ;
1030 for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
1031 Char_t * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQAv1::GetDetName(iDet), AliQAv1::GetQADataFileName(), runNumber));
1032 if (file)
1033 merger.AddFile(file);
1034 delete[] file;
1035 }
1036 merger.Merge() ;
1037 return kTRUE ;
1038}
1039
1040//_____________________________________________________________________________
1041Bool_t AliQAManager::MergeResults(const Int_t runNumber) const
1042{
1043 // Merge the QA result from all the data chunks in a run
1044 // to be revised whwn it will be used (see MergeData)
1045 TString cmd ;
1046 cmd = Form(".! ls %s*.root > tempo.txt", AliQAv1::GetQADataFileName()) ;
1047 gROOT->ProcessLine(cmd.Data()) ;
1048 ifstream in("tempo.txt") ;
1049 const Int_t chunkMax = 100 ;
1050 TString fileList[chunkMax] ;
1051
1052 Int_t index = 0 ;
1053 while ( 1 ) {
1054 TString file ;
1055 in >> fileList[index] ;
1056 if ( !in.good() )
1057 break ;
1058 AliDebug(AliQAv1::GetQADebugLevel(), Form("index = %d file = %s", index, (fileList[index].Data()))) ;
1059 index++ ;
1060 }
1061
1062 if ( index == 0 ) {
1063 AliError("No QA Result File found") ;
1064 return kFALSE ;
1065 }
1066
1067 TFileMerger merger ;
1068 TString outFileName ;
1069 if (runNumber != -1)
1070 outFileName = Form("Merged.%s.Result.%d.root",AliQAv1::GetQADataFileName(),runNumber);
1071 else
1072 outFileName = Form("Merged.%s.Result.root",AliQAv1::GetQADataFileName());
1073 merger.OutputFile(outFileName.Data()) ;
1074 for (Int_t ifile = 0 ; ifile < index ; ifile++) {
1075 TString file = fileList[ifile] ;
1076 merger.AddFile(file) ;
1077 }
1078 merger.Merge() ;
1079
1080 return kTRUE ;
1081}
1082
1083//_____________________________________________________________________________
1084void AliQAManager::Reset(const Bool_t sameCycle)
1085{
1086 // Reset the default data members
1087
1088 for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
1089 if (IsSelected(AliQAv1::GetDetName(iDet))) {
1090 AliQADataMaker * qadm = GetQADataMaker(iDet);
1091 qadm->Reset();
1092 }
1093 }
1094 if (fRawReaderDelete) {
1095 delete fRawReader ;
1096 fRawReader = NULL ;
1097 }
1098
1099 fCycleSame = sameCycle ;
1100 fESD = NULL ;
1101 fESDTree = NULL ;
1102 //fFirst = kTRUE ;
1103 fNumberOfEvents = 999999 ;
1104}
1105
1106//_____________________________________________________________________________
1107void AliQAManager::ResetDetectors(AliQAv1::TASKINDEX_t task, AliQAv1::DETECTORINDEX_t det)
1108{
1109 //calls ResetDetector of specified or all detectors
1110 UInt_t iDet = 0 ;
1111 UInt_t iDetMax = fgkNDetectors ;
1112 if ( det != AliQAv1::kNULLDET ) {
1113 iDet = det ;
1114 iDetMax = det+1 ;
1115 }
1116
1117 for (iDet = 0; iDet < iDetMax ; iDet++) {
1118 if (IsSelected(AliQAv1::GetDetName(iDet))) {
1119 AliQADataMaker * qadm = GetQADataMaker(iDet);
1120 qadm->ResetDetector(task);
1121 }
1122 }
1123}
1124
1125//_____________________________________________________________________________
1126AliQAManager * AliQAManager::QAManager(AliQAv1::MODE_t mode, TMap *entryCache, Int_t run)
1127{
1128 // returns AliQAManager instance (singleton)
1129
1130 if (!fgQAInstance) {
1131 if ( (mode != AliQAv1::kSIMMODE) && (mode != AliQAv1::kRECMODE) ) {
1132 AliWarningClass("You must specify kSIMMODE or kRECMODE") ;
1133 return NULL ;
1134 }
1135 fgQAInstance = new AliQAManager(mode) ;
1136 if (!entryCache)
1137 fgQAInstance->Init();
1138 else
1139 fgQAInstance->InitFromCache(entryCache,run);
1140 }
1141 return fgQAInstance;
1142}
1143
1144//_____________________________________________________________________________
1145AliQAManager * AliQAManager::QAManager(AliQAv1::TASKINDEX_t task)
1146{
1147 // returns AliQAManager instance (singleton)
1148 return QAManager(AliQAv1::Mode(task)) ;
1149}
1150
1151//_____________________________________________________________________________
1152TString AliQAManager::Run(const Char_t * detectors, AliRawReader * rawReader, const Bool_t sameCycle)
1153{
1154 //Runs all the QA data Maker for Raws only
1155
1156 fCycleSame = sameCycle ;
1157 fRawReader = rawReader ;
1158 fDetectors = detectors ;
1159 fDetectorsW = detectors ;
1160
1161 AliCDBManager* man = AliCDBManager::Instance() ;
1162
1163 if ( man->GetRun() == -1 ) {// check if run number not set previously and set it from raw data
1164 rawReader->NextEvent() ;
1165 man->SetRun(fRawReader->GetRunNumber()) ;
1166 rawReader->RewindEvents() ;
1167 }
1168
1169 if (!fCycleSame)
1170 if ( !InitQA(AliQAv1::kRAWS) )
1171 return "" ;
1172 fRawReaderDelete = kFALSE ;
1173
1174 DoIt(AliQAv1::kRAWS) ;
1175 return fDetectorsW ;
1176}
1177
1178//_____________________________________________________________________________
1179TString AliQAManager::Run(const Char_t * detectors, const Char_t * fileName, const Bool_t sameCycle)
1180{
1181 //Runs all the QA data Maker for Raws only
1182
1183 fCycleSame = sameCycle ;
1184 fDetectors = detectors ;
1185 fDetectorsW = detectors ;
1186
1187 AliCDBManager* man = AliCDBManager::Instance() ;
1188 if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
1189 AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
1190 if ( ! rl ) {
1191 AliFatal("galice.root file not found in current directory") ;
1192 } else {
1193 rl->CdGAFile() ;
1194 rl->LoadgAlice() ;
1195 if ( ! rl->GetAliRun() ) {
1196 AliFatal("AliRun not found in galice.root") ;
1197 } else {
1198 rl->LoadHeader() ;
1199 man->SetRun(rl->GetHeader()->GetRun());
1200 }
1201 }
1202 }
1203
1204 if (!fCycleSame)
1205 if ( !InitQA(AliQAv1::kRAWS, fileName) )
1206 return "" ;
1207
1208 DoIt(AliQAv1::kRAWS) ;
1209 return fDetectorsW ;
1210}
1211
1212//_____________________________________________________________________________
1213TString AliQAManager::Run(const Char_t * detectors, const AliQAv1::TASKINDEX_t taskIndex, Bool_t const sameCycle, const Char_t * fileName )
1214{
1215 // Runs all the QA data Maker for every detector
1216
1217 fCycleSame = sameCycle ;
1218 fDetectors = detectors ;
1219 fDetectorsW = detectors ;
1220
1221 AliCDBManager* man = AliCDBManager::Instance() ;
1222 if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
1223 AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
1224 if ( ! rl ) {
1225 AliFatal("galice.root file not found in current directory") ;
1226 } else {
1227 rl->CdGAFile() ;
1228 rl->LoadgAlice() ;
1229 if ( ! rl->GetAliRun() ) {
1230 AliDebug(AliQAv1::GetQADebugLevel(), "AliRun not found in galice.root") ;
1231 } else {
1232 rl->LoadHeader() ;
1233 man->SetRun(rl->GetHeader()->GetRun()) ;
1234 }
1235 }
1236 }
1237 if ( taskIndex == AliQAv1::kNULLTASKINDEX) {
1238 for (UInt_t task = 0; task < AliQAv1::kNTASKINDEX; task++) {
1239 if ( fTasks.Contains(Form("%d", task)) ) {
1240 if (!fCycleSame)
1241 if ( !InitQA(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(task)), fileName) )
1242 return "" ;
1243 DoIt(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(task))) ;
1244 }
1245 }
1246 } else {
1247 if (! fCycleSame )
1248 if ( !InitQA(taskIndex, fileName) )
1249 return "" ;
1250 DoIt(taskIndex) ;
1251 }
1252 return fDetectorsW ;
1253}
1254
1255//_____________________________________________________________________________
1256void AliQAManager::RunOneEvent(AliRawReader * rawReader)
1257{
1258 //Runs all the QA data Maker for Raws only and on one event only (event loop done by calling method)
1259 if ( ! rawReader )
1260 return ;
1261 if (fTasks.Contains(Form("%d", AliQAv1::kRAWS))){
1262 for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1263 if (!IsSelected(AliQAv1::GetDetName(iDet)))
1264 continue;
1265 AliQADataMaker *qadm = GetQADataMaker(iDet);
1266 if (!qadm)
1267 continue;
1268 if ( qadm->IsCycleDone() ) {
1269 qadm->EndOfCycle() ;
1270 }
1271 qadm->SetEventSpecie(fEventSpecie) ;
1272 if ( qadm->GetRecoParam() )
1273 if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
1274 qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
1275 qadm->Exec(AliQAv1::kRAWS, rawReader) ;
1276 }
1277 }
1278}
1279
1280//_____________________________________________________________________________
1281void AliQAManager::RunOneEvent(AliESDEvent *& esd, AliESDEvent *& hltesd)
1282{
1283 //Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
1284
1285 if (fTasks.Contains(Form("%d", AliQAv1::kESDS))) {
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 qadm->SetEventSpecie(fEventSpecie) ;
1293 if ( qadm->GetRecoParam() )
1294 if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
1295 qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
1296 if ( qadm->IsCycleDone() ) {
1297 qadm->EndOfCycle() ;
1298 }
1299 if (iDet == AliQAv1::kHLT) {
1300 TObjArray esdarray;
1301 esdarray.Add(esd);
1302 esdarray.Add(hltesd);
1303 qadm->Exec(AliQAv1::kESDS, &esdarray);
1304 } else {
1305 qadm->Exec(AliQAv1::kESDS, esd) ;
1306 }
1307 }
1308 }
1309}
1310
1311//_____________________________________________________________________________
1312void AliQAManager::RunOneEventInOneDetector(Int_t det, TTree * tree)
1313{
1314 // Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
1315
1316 TString test(tree->GetName()) ;
1317 if (fTasks.Contains(Form("%d", AliQAv1::kRECPOINTS))) {
1318 if (IsSelected(AliQAv1::GetDetName(det))) {
1319 AliQADataMaker *qadm = GetQADataMaker(det);
1320 if (qadm) {
1321 qadm->SetEventSpecie(fEventSpecie) ;
1322 if ( qadm->GetRecoParam() ) {
1323 if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
1324 qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
1325 else
1326 AliError(Form("%d defined by %s is not an event specie", qadm->GetRecoParam()->GetEventSpecie(), qadm->GetName())) ;
1327 }
1328 if ( qadm->IsCycleDone() ) {
1329 qadm->EndOfCycle() ;
1330 }
1331 if (test.Contains("TreeD")) {
1332 qadm->Exec(AliQAv1::kDIGITSR, tree) ;
1333 } else if (test.Contains("TreeR")) {
1334 qadm->Exec(AliQAv1::kRECPOINTS, tree) ;
1335 }
1336 }
1337 }
1338 }
1339}
1340
1341//_____________________________________________________________________________
1342Bool_t AliQAManager::Save2OCDB(const Int_t runNumber, AliRecoParam::EventSpecie_t es, const Char_t * year, const Char_t * detectors) const
1343{
1344 // take the locasl QA data merge into a single file and save in OCDB
1345 Bool_t rv = kTRUE ;
1346 TString tmp(AliQAv1::GetQARefStorage()) ;
1347 if ( tmp.IsNull() ) {
1348 AliError("No storage defined, use AliQAv1::SetQARefStorage") ;
1349 return kFALSE ;
1350 }
1351 if ( !(tmp.Contains(AliQAv1::GetLabLocalOCDB()) || tmp.Contains(AliQAv1::GetLabAliEnOCDB())) ) {
1352 AliError(Form("%s is a wrong storage, use %s or %s", AliQAv1::GetQARefStorage(), AliQAv1::GetLabLocalOCDB().Data(), AliQAv1::GetLabAliEnOCDB().Data())) ;
1353 return kFALSE ;
1354 }
1355 TString sdet(detectors) ;
1356 sdet.ToUpper() ;
1357 TFile * inputFile ;
1358 if ( sdet.Contains("ALL") ) {
1359 rv = Merge(runNumber) ;
1360 if ( ! rv )
1361 return kFALSE ;
1362 TString inputFileName(Form("Merged.%s.Data.%d.root", AliQAv1::GetQADataFileName(), runNumber)) ;
1363 inputFile = TFile::Open(inputFileName.Data()) ;
1364 rv = SaveIt2OCDB(runNumber, inputFile, year, es) ;
1365 } else {
1366 for (Int_t index = 0; index < AliQAv1::kNDET; index++) {
1367 if (sdet.Contains(AliQAv1::GetDetName(index))) {
1368 TString inputFileName(Form("%s.%s.%d.root", AliQAv1::GetDetName(index), AliQAv1::GetQADataFileName(), runNumber)) ;
1369 inputFile = TFile::Open(inputFileName.Data()) ;
1370 rv *= SaveIt2OCDB(runNumber, inputFile, year, es) ;
1371 }
1372 }
1373 }
1374 return rv ;
1375}
1376
1377//_____________________________________________________________________________
1378Bool_t AliQAManager::SaveIt2OCDB(const Int_t runNumber, TFile * inputFile, const Char_t * year, AliRecoParam::EventSpecie_t es) const
1379{
1380 // reads the TH1 from file and adds it to appropriate list before saving to OCDB
1381 Bool_t rv = kTRUE ;
1382 AliDebug(AliQAv1::GetQADebugLevel(), Form("Saving TH1s in %s to %s", inputFile->GetName(), AliQAv1::GetQARefStorage())) ;
1383 if ( ! IsDefaultStorageSet() ) {
1384 TString tmp( AliQAv1::GetQARefStorage() ) ;
1385 if ( tmp.Contains(AliQAv1::GetLabLocalOCDB()) )
1386 Instance()->SetDefaultStorage(AliQAv1::GetQARefStorage()) ;
1387 else {
1388 TString tmp1(AliQAv1::GetQARefDefaultStorage()) ;
1389 tmp1.Append(year) ;
1390 tmp1.Append("?user=alidaq") ;
1391 Instance()->SetDefaultStorage(tmp1.Data()) ;
1392 }
1393 }
1394 Instance()->SetSpecificStorage("*", AliQAv1::GetQARefStorage()) ;
1395 if(GetRun() < 0)
1396 Instance()->SetRun(runNumber);
1397
1398 AliCDBMetaData mdr ;
1399 mdr.SetResponsible("yves schutz");
1400
1401 for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++) {
1402 TDirectory * detDir = inputFile->GetDirectory(AliQAv1::GetDetName(detIndex)) ;
1403 if ( detDir ) {
1404 AliDebug(AliQAv1::GetQADebugLevel(), Form("Entering %s", detDir->GetName())) ;
1405 AliQAv1::SetQARefDataDirName(es) ;
1406 TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetDetName(detIndex), AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName())) ;
1407 AliCDBId idr(detOCDBDir.Data(), runNumber, AliCDBRunRange::Infinity()) ;
1408 TList * listDetQAD = new TList() ;
1409 TString listName(Form("%s QA data Reference", AliQAv1::GetDetName(detIndex))) ;
1410 mdr.SetComment(Form("%s QA stuff", AliQAv1::GetDetName(detIndex)));
1411 listDetQAD->SetName(listName) ;
1412 TList * taskList = detDir->GetListOfKeys() ;
1413 TIter nextTask(taskList) ;
1414 TKey * taskKey ;
1415 while ( (taskKey = static_cast<TKey*>(nextTask())) ) {
1416 TDirectory * taskDir = detDir->GetDirectory(taskKey->GetName()) ;
1417 TDirectory * esDir = taskDir->GetDirectory(AliRecoParam::GetEventSpecieName(es)) ;
1418 AliDebug(AliQAv1::GetQADebugLevel(), Form("Saving %s", esDir->GetName())) ;
1419 TObjArray * listTaskQAD = new TObjArray(100) ;
1420 listTaskQAD->SetName(Form("%s/%s", taskKey->GetName(), AliRecoParam::GetEventSpecieName(es))) ;
1421 listDetQAD->Add(listTaskQAD) ;
1422 TList * histList = esDir->GetListOfKeys() ;
1423 TIter nextHist(histList) ;
1424 TKey * histKey ;
1425 while ( (histKey = static_cast<TKey*>(nextHist())) ) {
1426 TObject * odata = esDir->Get(histKey->GetName()) ;
1427 if ( !odata ) {
1428 AliError(Form("%s in %s/%s returns a NULL pointer !!", histKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
1429 } else {
1430 if ( AliQAv1::GetExpert() == histKey->GetName() ) {
1431 TDirectory * expertDir = esDir->GetDirectory(histKey->GetName()) ;
1432 TList * expertHistList = expertDir->GetListOfKeys() ;
1433 TIter nextExpertHist(expertHistList) ;
1434 TKey * expertHistKey ;
1435 while ( (expertHistKey = static_cast<TKey*>(nextExpertHist())) ) {
1436 TObject * expertOdata = expertDir->Get(expertHistKey->GetName()) ;
1437 if ( !expertOdata ) {
1438 AliError(Form("%s in %s/%s/Expert returns a NULL pointer !!", expertHistKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
1439 } else {
1440 AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", expertHistKey->GetName())) ;
1441 if ( expertOdata->IsA()->InheritsFrom("TH1") ) {
1442 AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", expertHistKey->GetName())) ;
1443 TH1 * hExpertdata = static_cast<TH1*>(expertOdata) ;
1444 listTaskQAD->Add(hExpertdata) ;
1445 }
1446 }
1447 }
1448 }
1449 AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", histKey->GetName())) ;
1450 if ( odata->IsA()->InheritsFrom("TH1") ) {
1451 AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", histKey->GetName())) ;
1452 TH1 * hdata = static_cast<TH1*>(odata) ;
1453 listTaskQAD->Add(hdata) ;
1454 }
1455 }
1456 }
1457 }
1458 Instance()->Put(listDetQAD, idr, &mdr) ;
1459 }
1460 }
1461 return rv ;
1462}
1463
1464//_____________________________________________________________________________
1465
1466void AliQAManager::SetCheckerExternParam(AliQAv1::DETECTORINDEX_t detIndex, TList * parameterList)
1467{
1468 // set the external parameters list for the detector checkers
1469 AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(detIndex) ;
1470 qac->SetExternParamlist(parameterList) ;
1471 qac->PrintExternParam() ;
1472}
1473
1474//_____________________________________________________________________________
1475void AliQAManager::SetEventSpecie(AliRecoParam::EventSpecie_t es)
1476{
1477 // set the current event specie and inform AliQAv1 that this event specie has been encountered
1478 fEventSpecie = es ;
1479 AliQAv1::Instance()->SetEventSpecie(es) ;
1480}
1481
1482//_____________________________________________________________________________
1483void AliQAManager::SetRecoParam(const Int_t det, const AliDetectorRecoParam *par)
1484{
1485 // Set custom reconstruction parameters for a given detector
1486 // Single set of parameters for all the events
1487 GetQADataMaker(det)->SetRecoParam(par) ;
1488}
1489
1490//_____________________________________________________________________________
1491void AliQAManager::SetWriteExpert()
1492{
1493 // enable the writing of QA expert data
1494 for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1495 if (IsSelected(AliQAv1::GetDetName(iDet)))
1496 fQAWriteExpert[iDet] = kTRUE ;
1497 }
1498}
1499
1500//_____________________________________________________________________________
1501void AliQAManager::Destroy() {
1502 // delete AliQAManager instance and
1503 // all associated objects
1504
1505 if (fgQAInstance) {
1506 delete fgQAInstance ;
1507 fgQAInstance = NULL ;
1508 }
1509}
1510
1511//_____________________________________________________________________________
1512void AliQAManager::ShowQA() {
1513 // Show the result of the QA checking
1514 // for all detectors
1515 for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++)
1516 AliQAv1::Instance(AliQAv1::GetDetIndex(AliQAv1::GetDetName(detIndex)))->Show() ;
1517}