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