Line data Source code
1 :
2 : /**************************************************************************
3 : * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 : * *
5 : * Author: The ALICE Off-line Project. *
6 : * Contributors are mentioned in the code where appropriate. *
7 : * *
8 : * Permission to use, copy, modify and distribute this software and its *
9 : * documentation strictly for non-commercial purposes is hereby granted *
10 : * without fee, provided that the above copyright notice appears in all *
11 : * copies and that both the copyright notice and this permission notice *
12 : * appear in the supporting documentation. The authors make no claims *
13 : * about the suitability of this software for any purpose. It is *
14 : * provided "as is" without express or implied warranty. *
15 : **************************************************************************/
16 : /* $Id$ */
17 :
18 : //////////////////////////////////////////////////////////////////////////////
19 : //
20 : // Quality Assurance Object//_________________________________________________________________________
21 : // Quality Assurance object. The QA status is held in one word per detector,
22 : // each bit corresponds to a different status.
23 : // bit 0-3 : QA raised during simulation (RAW)
24 : // bit 4-7 : QA raised during simulation (SIM)
25 : // bit 8-11 : QA raised during reconstruction (REC)
26 : // bit 12-15 : QA raised during ESD checking (ESD)
27 : // bit 16-19 : QA raised during analysis (ANA)
28 : // Each of the 4 bits corresponds to a severity level of increasing importance
29 : // from lower to higher bit (INFO, WARNING, ERROR, FATAL)
30 : //
31 : //*-- Yves Schutz CERN, July 2007
32 : //////////////////////////////////////////////////////////////////////////////
33 :
34 :
35 : #include <cstdlib>
36 : // --- ROOT system ---
37 : #include <TClass.h>
38 : #include <TFile.h>
39 : #include <TSystem.h>
40 : #include <TROOT.h>
41 :
42 : // --- Standard library ---
43 :
44 : // --- AliRoot header files ---
45 : #include "AliLog.h"
46 : #include "AliQA.h"
47 :
48 :
49 176 : ClassImp(AliQA)
50 : AliQA * AliQA::fgQA = 0x0 ;
51 : TFile * AliQA::fgQADataFile = 0x0 ;
52 176 : TString AliQA::fgQADataFileName = "QA" ; // will transform into Det.QA.run.cycle.root
53 : TFile * AliQA::fgQARefFile = 0x0 ;
54 176 : TString AliQA::fgQARefDirName = "" ;
55 176 : TString AliQA::fgQARefFileName = "QA.root" ;
56 : TFile * AliQA::fgQAResultFile = 0x0 ;
57 176 : TString AliQA::fgQAResultDirName = "" ;
58 176 : TString AliQA::fgQAResultFileName = "QA.root" ;
59 968 : TString AliQA::fgDetNames[] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD",
60 2728 : "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT", "Global", "CORR","MFT"};
61 176 : TString AliQA::fgGRPPath = "GRP/GRP/Data" ;
62 704 : TString AliQA::fgRTNames[] = {"UNKNOWN", "AUTO_TEST", "CALIBRATION", "CALIBRATION_PULSER", "CHANNEL_DELAY_TUNING", "COSMIC",
63 440 : "COSMICS", "DAQ_FO_UNIF_SCAN", "DAQ_GEN_DAC_SCAN", "DAQ_MEAN_TH_SCAN", "DAQ_MIN_TH_SCAN",
64 352 : "DAQ_NOISY_PIX_SCAN", "DAQ_PIX_DELAY_SCAN", "DAQ_UNIFORMITY_SCAN", "DCS_FO_UNIF_SCAN",
65 352 : "DCS_MEAN_TH_SCAN", "DCS_MIN_TH_SCAN", "DCS_PIX_DELAY_SCAN", "DCS_UNIFORMITY_SCAN",
66 704 : "DDL_TEST", "GAIN", "PEDESTAL", "INJECTOR", "LASER", "MONTECARLO", "NOISE", "NOISY_PIX_SCAN",
67 528 : "PHYSICS", "PULSER", "STANDALONE", "STANDALONE_BC", "STANDALONE_CENTRAL", "STANDALONE_COSMIC",
68 352 : "STANDALONE_EMD", "STANDALONE_LASER", "STANDALONE_MB", "STANDALONE_PEDESTAL",
69 3960 : "STANDALONE_SEMICENTRAL", "STANDALONE_PULSER" } ;
70 1848 : TString AliQA::fgTaskNames[] = {"Raws", "Hits", "SDigits", "Digits", "RecPoints", "TrackSegments", "RecParticles", "ESDs"} ;
71 176 : const TString AliQA::fgkLabLocalFile = "file://" ;
72 176 : const TString AliQA::fgkLabLocalOCDB = "local://" ;
73 176 : const TString AliQA::fgkLabAliEnOCDB = "alien://" ;
74 176 : const TString AliQA::fgkRefFileName = "QA.root" ;
75 176 : const TString AliQA::fgkQAName = "QA" ;
76 176 : const TString AliQA::fgkQACorrNtName = "CorrQA" ;
77 176 : const TString AliQA::fgkRefOCDBDirName = "Ref" ;
78 176 : TString AliQA::fgkRefDataDirName = "" ;
79 176 : const TString AliQA::fgkQARefOCDBDefault = "alien://folder=/alice/QA/20" ;
80 176 : const TString AliQA::fgkExpert = "Expert" ;
81 : const UInt_t AliQA::fgkExpertBit = 16 ;
82 : const UInt_t AliQA::fgkQABit = 17 ;
83 :
84 : //____________________________________________________________________________
85 : AliQA::AliQA() :
86 6 : TNamed("", ""),
87 6 : fNdet(kNDET),
88 12 : fQA(new ULong_t[fNdet]),
89 6 : fDet(kNULLDET),
90 6 : fTask(kNULLTASK)
91 :
92 30 : {
93 : // default constructor
94 : // beware singleton: not to be used
95 :
96 216 : for (Int_t index = 0 ; index < fNdet ; index++)
97 102 : fQA[index] = 0 ;
98 12 : }
99 :
100 : //____________________________________________________________________________
101 : AliQA::AliQA(const AliQA& qa) :
102 0 : TNamed(qa),
103 0 : fNdet(qa.fNdet),
104 0 : fQA(new ULong_t[qa.fNdet]),
105 0 : fDet(qa.fDet),
106 0 : fTask(qa.fTask)
107 0 : {
108 : // cpy ctor
109 0 : memcpy(fQA, qa.fQA, sizeof(ULong_t)*fNdet);
110 0 : }
111 :
112 : //_____________________________________________________________________________
113 : AliQA& AliQA::operator = (const AliQA& qa)
114 : {
115 : //
116 : // Assignment operator
117 4 : if(this != &qa) {
118 2 : TNamed::operator=(qa);
119 2 : fNdet = qa.fNdet;
120 4 : delete [] fQA;
121 2 : fQA = new ULong_t[fNdet];
122 2 : memcpy(fQA, qa.fQA, sizeof(ULong_t)*fNdet);
123 2 : fDet = qa.fDet;
124 2 : fTask = qa.fTask;
125 2 : }
126 2 : return *this;
127 : }
128 :
129 : //_______________________________________________________________
130 : AliQA::AliQA(const DETECTORINDEX_t det) :
131 0 : TNamed("QA", "Quality Assurance status"),
132 0 : fNdet(kNDET),
133 0 : fQA(new ULong_t[fNdet]),
134 0 : fDet(det),
135 0 : fTask(kNULLTASK)
136 0 : {
137 : // constructor to be used
138 0 : if (! CheckRange(det) ) {
139 0 : fDet = kNULLDET ;
140 0 : return ;
141 : }
142 : Int_t index ;
143 0 : for (index = 0; index < fNdet; index++)
144 0 : fQA[index] = 0 ;
145 0 : }
146 :
147 : //_______________________________________________________________
148 : AliQA::AliQA(const ALITASK_t tsk) :
149 0 : TNamed("QA", "Quality Assurance status"),
150 0 : fNdet(kNDET),
151 0 : fQA(new ULong_t[fNdet]),
152 0 : fDet(kNULLDET),
153 0 : fTask(tsk)
154 0 : {
155 : // constructor to be used in the AliRoot module (SIM, REC, ESD or ANA)
156 0 : if (! CheckRange(tsk) ) {
157 0 : fTask = kNULLTASK ;
158 0 : return ;
159 : }
160 : Int_t index ;
161 0 : for (index = 0; index < fNdet; index++)
162 0 : fQA[index] = 0 ;
163 0 : }
164 :
165 : //____________________________________________________________________________
166 : AliQA::~AliQA()
167 8 : {
168 : // dtor
169 4 : delete[] fQA ;
170 4 : }
171 :
172 : //_______________________________________________________________
173 : void AliQA::Close()
174 : {
175 : // close the open files
176 0 : if (fgQADataFile)
177 0 : if (fgQADataFile->IsOpen())
178 0 : fgQADataFile->Close() ;
179 0 : if (fgQAResultFile)
180 0 : if (fgQAResultFile->IsOpen())
181 0 : fgQAResultFile->Close() ;
182 0 : if (fgQARefFile)
183 0 : if (fgQARefFile->IsOpen())
184 0 : fgQARefFile->Close() ;
185 0 : }
186 :
187 : //_______________________________________________________________
188 : Bool_t AliQA::CheckFatal() const
189 : {
190 : // check if any FATAL status is set
191 : Bool_t rv = kFALSE ;
192 : Int_t index ;
193 0 : for (index = 0; index < kNDET ; index++)
194 0 : rv = rv || IsSet(DETECTORINDEX_t(index), fTask, kFATAL) ;
195 0 : return rv ;
196 : }
197 :
198 : //_______________________________________________________________
199 : Bool_t AliQA::CheckRange(DETECTORINDEX_t det) const
200 : {
201 : // check if detector is in given detector range: 0-kNDET
202 :
203 0 : Bool_t rv = ( det < 0 || det > kNDET ) ? kFALSE : kTRUE ;
204 0 : if (!rv)
205 0 : AliFatal(Form("Detector index %d is out of range: 0 <= index <= %d", det, kNDET)) ;
206 0 : return rv ;
207 : }
208 :
209 : //_______________________________________________________________
210 : Bool_t AliQA::CheckRange(ALITASK_t task) const
211 : {
212 : // check if task is given taskk range: 0:kNTASK
213 0 : Bool_t rv = ( task < kRAW || task > kNTASK ) ? kFALSE : kTRUE ;
214 0 : if (!rv)
215 0 : AliFatal(Form("Module index %d is out of range: 0 <= index <= %d", task, kNTASK)) ;
216 0 : return rv ;
217 : }
218 :
219 : //_______________________________________________________________
220 : Bool_t AliQA::CheckRange(QABIT_t bit) const
221 : {
222 : // check if bit is in given bit range: 0-kNBit
223 :
224 0 : Bool_t rv = ( bit < 0 || bit > kNBIT ) ? kFALSE : kTRUE ;
225 0 : if (!rv)
226 0 : AliFatal(Form("Status bit %d is out of range: 0 <= bit <= %d", bit, kNBIT)) ;
227 0 : return rv ;
228 : }
229 :
230 :
231 :
232 : //_______________________________________________________________
233 : char * AliQA::GetAliTaskName(ALITASK_t tsk)
234 : {
235 : // returns the char name corresponding to module index
236 0 : TString tskName ;
237 0 : switch (tsk) {
238 : case kNULLTASK:
239 : break ;
240 : case kRAW:
241 0 : tskName = "RAW" ;
242 : break ;
243 : case kSIM:
244 0 : tskName = "SIM" ;
245 : break ;
246 : case kREC:
247 0 : tskName = "REC" ;
248 : break ;
249 : case kESD:
250 0 : tskName = "ESD" ;
251 : break ;
252 : case kANA:
253 0 : tskName = "ANA" ;
254 : break ;
255 : default:
256 : tsk = kNULLTASK ;
257 0 : break ;
258 : }
259 0 : return Form("%s", tskName.Data()) ;
260 0 : }
261 :
262 : //_______________________________________________________________
263 : char * AliQA::GetBitName(QABIT_t bit) const
264 : {
265 : // returns the char name corresponding to bit
266 0 : TString bitName ;
267 0 : switch (bit) {
268 : case kNULLBit:
269 : break ;
270 : case kINFO:
271 0 : bitName = "INFO" ;
272 : break ;
273 : case kWARNING:
274 0 : bitName = "WARNING" ;
275 : break ;
276 : case kERROR:
277 0 : bitName = "ERROR" ;
278 : break ;
279 : case kFATAL:
280 0 : bitName = "FATAL" ;
281 : break ;
282 : default:
283 : bit = kNULLBit ;
284 0 : break ;
285 : }
286 0 : return Form("%s", bitName.Data()) ;
287 0 : }
288 :
289 : //_______________________________________________________________
290 : AliQA::DETECTORINDEX_t AliQA::GetDetIndex(const char * name)
291 : {
292 : // returns the detector index corresponding to a given name
293 0 : TString sname(name) ;
294 : DETECTORINDEX_t rv = kNULLDET ;
295 0 : for (Int_t det = 0; det < kNDET ; det++) {
296 0 : if ( GetDetName(det) == sname ) {
297 : rv = DETECTORINDEX_t(det) ;
298 0 : break ;
299 : }
300 : }
301 : return rv ;
302 0 : }
303 :
304 : //_______________________________________________________________
305 : const char * AliQA::GetDetName(Int_t det)
306 : {
307 : // returns the detector name corresponding to a given index (needed in a loop)
308 :
309 0 : if ( det >= 0 && det < kNDET)
310 0 : return (fgDetNames[det]).Data() ;
311 : else
312 0 : return NULL ;
313 0 : }
314 :
315 : //_______________________________________________________________
316 : TFile * AliQA::GetQADataFile(const char * name, const Int_t run)
317 : {
318 : // opens the file to store the detectors Quality Assurance Data Maker results
319 0 : const char * temp = Form("%s.%s.%d.root", name, fgQADataFileName.Data(), run) ;
320 0 : TString opt ;
321 0 : if (! fgQADataFile ) {
322 0 : if (gSystem->AccessPathName(temp))
323 0 : opt = "NEW" ;
324 : else
325 0 : opt = "UPDATE" ;
326 0 : fgQADataFile = TFile::Open(temp, opt.Data()) ;
327 0 : } else {
328 0 : if ( strcmp(temp, fgQADataFile->GetName()) != 0 ) {
329 0 : fgQADataFile = dynamic_cast<TFile *>(gROOT->FindObject(temp)) ;
330 0 : if ( !fgQADataFile ) {
331 0 : if (gSystem->AccessPathName(temp))
332 0 : opt = "NEW" ;
333 : else
334 0 : opt = "UPDATE" ;
335 0 : fgQADataFile = TFile::Open(temp, opt.Data()) ;
336 0 : }
337 : }
338 : }
339 0 : return fgQADataFile ;
340 0 : }
341 :
342 : //_____________________________________________________________________________
343 : TFile * AliQA::GetQADataFile(const char * fileName)
344 : {
345 : // Open if necessary the Data file and return its pointer
346 :
347 0 : if (!fgQADataFile)
348 0 : if (!fileName)
349 0 : fileName = AliQA::GetQADataFileName() ;
350 0 : if (!gSystem->AccessPathName(fileName)) {
351 0 : fgQADataFile = TFile::Open(fileName) ;
352 0 : } else {
353 0 : AliFatalClass(Form("File %s not found", fileName)) ;
354 : }
355 0 : return fgQADataFile ;
356 : }
357 :
358 : //_______________________________________________________________
359 : TFile * AliQA::GetQAResultFile()
360 : {
361 : // opens the file to store the Quality Assurance Data Checker results
362 0 : if (fgQAResultFile)
363 0 : fgQAResultFile->Close() ;
364 0 : fgQAResultFile = 0x0 ;
365 : // if (!fgQAResultFile) {
366 0 : TString dirName(fgQAResultDirName) ;
367 0 : if ( dirName.Contains(fgkLabLocalFile))
368 0 : dirName.ReplaceAll(fgkLabLocalFile, "") ;
369 0 : TString fileName(dirName + fgQAResultFileName) ;
370 0 : TString opt("") ;
371 0 : if ( !gSystem->AccessPathName(fileName) )
372 0 : opt = "UPDATE" ;
373 : else {
374 0 : if ( gSystem->AccessPathName(dirName) )
375 0 : gSystem->mkdir(dirName) ;
376 0 : opt = "NEW" ;
377 : }
378 0 : fgQAResultFile = TFile::Open(fileName, opt) ;
379 : // }
380 :
381 : return fgQAResultFile ;
382 0 : }
383 :
384 : //_______________________________________________________________
385 : const TString AliQA::GetRunTypeName(RUNTYPE_t rt)
386 : {
387 : // returns the name of a run type
388 0 : TString rv("Invalid Run Type") ;
389 0 : if ( rt == kNULLTYPE ) {
390 0 : rv = "Known RUN_TYPE are: \n" ;
391 0 : for (Int_t index = 0 ; index < kNTYPE; index++) {
392 0 : rv += Form("%2d -- %s\n", index, fgRTNames[index].Data()) ;
393 : }
394 0 : AliErrorClass(Form("%s", rv.Data())) ;
395 0 : return "" ;
396 : }
397 : else {
398 0 : if ( rt > kNULLTYPE && rt < kNTYPE )
399 0 : rv = fgRTNames[rt] ;
400 : }
401 0 : return rv ;
402 0 : }
403 :
404 : //_______________________________________________________________
405 : AliQA::TASKINDEX_t AliQA::GetTaskIndex(const char * name)
406 : {
407 : // returns the detector index corresponding to a given name
408 0 : TString sname(name) ;
409 : TASKINDEX_t rv = kNULLTASKINDEX ;
410 0 : for (Int_t tsk = 0; tsk < kNTASKINDEX ; tsk++) {
411 0 : if ( GetTaskName(tsk) == sname ) {
412 : rv = TASKINDEX_t(tsk) ;
413 0 : break ;
414 : }
415 : }
416 : return rv ;
417 0 : }
418 :
419 : //_______________________________________________________________
420 : Bool_t AliQA::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit) const
421 : {
422 : // Checks is the requested bit is set
423 :
424 0 : CheckRange(det) ;
425 0 : CheckRange(tsk) ;
426 0 : CheckRange(bit) ;
427 :
428 0 : ULong_t offset = Offset(tsk) ;
429 0 : ULong_t status = GetStatus(det) ;
430 0 : offset+= bit ;
431 0 : status = (status & 1 << offset) != 0 ;
432 0 : return status ;
433 : }
434 :
435 : //_______________________________________________________________
436 : Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk) const
437 : {
438 : // Checks is the requested bit is set
439 :
440 0 : CheckRange(det) ;
441 0 : CheckRange(tsk) ;
442 :
443 0 : ULong_t offset = Offset(tsk) ;
444 0 : ULong_t status = GetStatus(det) ;
445 : UShort_t st = 0 ;
446 0 : for ( Int_t bit = 0 ; bit < kNBIT ; bit++) {
447 0 : offset+= bit ;
448 0 : st += (status & 1 << offset) != 0 ;
449 : }
450 0 : if ( st == 0 )
451 0 : return kFALSE ;
452 : else
453 0 : return kTRUE ;
454 0 : }
455 : //_______________________________________________________________
456 : Bool_t AliQA::IsSetAny(DETECTORINDEX_t det) const
457 : {
458 : // Checks is the requested bit is set
459 :
460 0 : CheckRange(det) ;
461 :
462 0 : ULong_t status = GetStatus(det) ;
463 : UShort_t st = 0 ;
464 0 : for ( Int_t tsk = 0 ; tsk < kNTASK ; tsk++) {
465 0 : ULong_t offset = Offset(ALITASK_t(tsk)) ;
466 0 : for ( Int_t bit = 0 ; bit < kNBIT ; bit++) {
467 0 : offset+= bit ;
468 0 : st += (status & 1 << offset) != 0 ;
469 : }
470 : }
471 0 : if ( st == 0 )
472 0 : return kFALSE ;
473 : else
474 0 : return kTRUE ;
475 0 : }
476 :
477 : //_______________________________________________________________
478 : AliQA * AliQA::Instance()
479 : {
480 : // Get an instance of the singleton.
481 : // Object must have been instantiated with Instance(ALITASK) first
482 :
483 0 : return fgQA ;
484 : }
485 :
486 : //_______________________________________________________________
487 : AliQA * AliQA::Instance(const DETECTORINDEX_t det)
488 : {
489 : // Get an instance of the singleton. The only authorized way to call the ctor
490 :
491 0 : if ( ! fgQA) {
492 0 : TFile * f = GetQAResultFile() ;
493 0 : fgQA = dynamic_cast<AliQA *>(f->Get("QA")) ;
494 0 : if ( ! fgQA )
495 0 : fgQA = new AliQA(det) ;
496 0 : }
497 0 : fgQA->Set(det) ;
498 0 : return fgQA ;
499 0 : }
500 :
501 : //_______________________________________________________________
502 : AliQA * AliQA::Instance(const ALITASK_t tsk)
503 : {
504 : // get an instance of the singleton.
505 :
506 0 : if ( ! fgQA)
507 0 : switch (tsk) {
508 : case kNULLTASK:
509 : break ;
510 : case kRAW:
511 0 : fgQA = new AliQA(tsk) ;
512 0 : break ;
513 : case kSIM:
514 0 : fgQA = new AliQA(tsk) ;
515 0 : break ;
516 : case kREC:
517 0 : AliInfoClass("fgQA = gAlice->GetQA()") ;
518 0 : break ;
519 : case kESD:
520 0 : AliInfoClass("fgQA = dynamic_cast<AliQA *> (esdFile->Get(\"QA\")") ;
521 0 : break ;
522 : case kANA:
523 0 : AliInfoClass("fgQA = dynamic_cast<AliQA *> (esdFile->Get(\"QA\")") ;
524 0 : break ;
525 : case kNTASK:
526 : break ;
527 : }
528 0 : if (fgQA)
529 0 : fgQA->Set(tsk) ;
530 0 : return fgQA ;
531 0 : }
532 :
533 : //_______________________________________________________________
534 : AliQA * AliQA::Instance(const TASKINDEX_t tsk)
535 : {
536 : // get an instance of the singleton.
537 :
538 : ALITASK_t index = kNULLTASK ;
539 :
540 0 : if ( tsk == kRAWS )
541 0 : index = kRAW ;
542 0 : else if (tsk < kDIGITS)
543 0 : index = kSIM ;
544 0 : else if (tsk < kRECPARTICLES)
545 0 : index = kREC ;
546 0 : else if (tsk == kESDS)
547 0 : index = kESD ;
548 :
549 0 : return Instance(index) ;
550 : }
551 :
552 : //_______________________________________________________________
553 : Long64_t AliQA::Merge(const TCollection * list) {
554 : // Merge the QA resuls in the list into this single AliQA object
555 :
556 : Long64_t nmerge=0;
557 0 : for (Int_t det = 0 ; det < kNDET ; det++) {
558 0 : Set(DETECTORINDEX_t(det)) ;
559 0 : for (Int_t task = 0 ; task < kNTASK ; task++) {
560 0 : Set(ALITASK_t(task)) ;
561 0 : for (Int_t bit = 0 ; bit < kNBIT ; bit++) {
562 0 : TIter next(list) ;
563 : AliQA * qa ;
564 0 : while ( (qa = (AliQA*)next() ) ) {
565 0 : ++nmerge;
566 0 : qa->IsSet(DETECTORINDEX_t(det), ALITASK_t(task), QABIT_t(bit)) ;
567 0 : Set(QABIT_t(bit)) ;
568 : } // qa list
569 0 : } // bit
570 : } // task
571 : } // detector
572 0 : return nmerge;
573 0 : }
574 :
575 : //_______________________________________________________________
576 : ULong_t AliQA::Offset(ALITASK_t tsk) const
577 : {
578 : // Calculates the bit offset for a given module (SIM, REC, ESD, ANA)
579 :
580 0 : CheckRange(tsk) ;
581 :
582 : ULong_t offset = 0 ;
583 0 : switch (tsk) {
584 : case kNULLTASK:
585 : break ;
586 : case kRAW:
587 : offset+= 0 ;
588 0 : break ;
589 : case kSIM:
590 : offset+= 4 ;
591 0 : break ;
592 : case kREC:
593 : offset+= 8 ;
594 0 : break ;
595 : case kESD:
596 : offset+= 12 ;
597 0 : break ;
598 : case kANA:
599 : offset+= 16 ;
600 0 : break ;
601 : case kNTASK:
602 : break ;
603 : }
604 :
605 0 : return offset ;
606 : }
607 :
608 : //_______________________________________________________________
609 : void AliQA::Set(QABIT_t bit)
610 : {
611 : // Set the status bit of the current detector in the current module
612 :
613 0 : SetStatusBit(fDet, fTask, bit) ;
614 0 : }
615 :
616 : //_____________________________________________________________________________
617 : void AliQA::SetQARefStorage(const char * name)
618 : {
619 : // Set the root directory where the QA reference data are stored
620 :
621 0 : fgQARefDirName = name ;
622 0 : if ( fgQARefDirName.Contains(fgkLabLocalFile) )
623 0 : fgQARefFileName = fgkRefFileName ;
624 0 : else if ( fgQARefDirName.Contains(fgkLabLocalOCDB) )
625 0 : fgQARefFileName = fgkQAName ;
626 0 : else if ( fgQARefDirName.Contains(fgkLabAliEnOCDB) )
627 0 : fgQARefFileName = fgkQAName ;
628 :
629 : else {
630 0 : AliErrorClass(Form("%s is an invalid storage definition\n", name)) ;
631 0 : fgQARefDirName = "" ;
632 0 : fgQARefFileName = "" ;
633 : }
634 0 : TString tmp(fgQARefDirName) ; // + fgQARefFileName) ;
635 0 : AliInfoClass(Form("AliQA::SetQARefDir: QA references are in %s\n", tmp.Data()) ) ;
636 0 : }
637 :
638 : //_____________________________________________________________________________
639 : void AliQA::SetQARefDataDirName(const char * name)
640 : {
641 : // Set the lower level directory name where reference data are found
642 0 : TString test(name) ;
643 : RUNTYPE_t rt = kNULLTYPE ;
644 0 : for (Int_t index = 0; index < kNTYPE; index++) {
645 0 : if (test.CompareTo(fgRTNames[index]) == 0) {
646 : rt = (RUNTYPE_t) index ;
647 0 : break ;
648 : }
649 : }
650 :
651 0 : if (rt == kNULLTYPE) {
652 0 : AliWarningClass(Form("AliQA::SetQARefDataDirName: %s is an unknown RUN TYPE name\n", name)) ;
653 0 : return ;
654 : }
655 :
656 0 : SetQARefDataDirName(rt) ;
657 0 : }
658 :
659 : //_____________________________________________________________________________
660 : void AliQA::SetQAResultDirName(const char * name)
661 : {
662 : // Set the root directory where to store the QA status object
663 :
664 0 : fgQAResultDirName.Prepend(name) ;
665 0 : AliInfoClass(Form("AliQA::SetQAResultDirName: QA results are in %s\n", fgQAResultDirName.Data())) ;
666 0 : if ( fgQAResultDirName.Contains(fgkLabLocalFile))
667 0 : fgQAResultDirName.ReplaceAll(fgkLabLocalFile, "") ;
668 0 : fgQAResultFileName.Prepend(fgQAResultDirName) ;
669 0 : }
670 :
671 : //_______________________________________________________________
672 : void AliQA::SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit)
673 : {
674 : // Set the status bit for a given detector and a given task
675 :
676 0 : CheckRange(det) ;
677 0 : CheckRange(tsk) ;
678 0 : CheckRange(bit) ;
679 :
680 0 : ULong_t offset = Offset(tsk) ;
681 0 : ULong_t status = GetStatus(det) ;
682 0 : offset+= bit ;
683 0 : status = status | 1 << offset ;
684 0 : SetStatus(det, status) ;
685 0 : }
686 :
687 : //_______________________________________________________________
688 : void AliQA::ShowAll() const
689 : {
690 : // dispplay the QA status word
691 : Int_t index ;
692 0 : for (index = 0 ; index < kNDET ; index++) {
693 0 : for (Int_t tsk = kRAW ; tsk < kNTASK ; tsk++) {
694 0 : ShowStatus(DETECTORINDEX_t(index), ALITASK_t(tsk)) ;
695 : }
696 : }
697 0 : }
698 :
699 : //_______________________________________________________________
700 : void AliQA::ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk) const
701 : {
702 : // Prints the full QA status of a given detector
703 0 : CheckRange(det) ;
704 0 : ULong_t status = GetStatus(det) ;
705 0 : ULong_t tskStatus[kNTASK] ;
706 0 : tskStatus[kRAW] = status & 0x0000f ;
707 0 : tskStatus[kSIM] = status & 0x000f0 ;
708 0 : tskStatus[kREC] = status & 0x00f00 ;
709 0 : tskStatus[kESD] = status & 0x0f000 ;
710 0 : tskStatus[kANA] = status & 0xf0000 ;
711 :
712 0 : AliInfo(Form("====> QA Status for %8s raw =0x%lx, sim=0x%lx, rec=0x%lx, esd=0x%lx, ana=0x%lx", GetDetName(det).Data(),
713 : tskStatus[kRAW], tskStatus[kSIM], tskStatus[kREC], tskStatus[kESD], tskStatus[kANA] )) ;
714 0 : if (tsk == kNULLTASK) {
715 0 : for (Int_t itsk = kRAW ; itsk < kNTASK ; itsk++) {
716 0 : ShowASCIIStatus(det, ALITASK_t(itsk), tskStatus[itsk]) ;
717 : }
718 0 : } else {
719 0 : ShowASCIIStatus(det, tsk, tskStatus[tsk]) ;
720 : }
721 0 : }
722 :
723 : //_______________________________________________________________
724 : void AliQA::ShowASCIIStatus(DETECTORINDEX_t det, ALITASK_t tsk, const ULong_t status) const
725 : {
726 : // print the QA status in human readable format
727 0 : TString text;
728 0 : for (Int_t bit = kINFO ; bit < kNBIT ; bit++) {
729 0 : if (IsSet(det, tsk, QABIT_t(bit))) {
730 0 : text = GetBitName(QABIT_t(bit)) ;
731 0 : text += " " ;
732 : }
733 : }
734 0 : if (! text.IsNull())
735 0 : AliWarningClass(Form(" %8s %4s 0x%4lx, Problem signalled: %8s \n", GetDetName(det).Data(), GetAliTaskName(tsk), status, text.Data())) ;
736 0 : }
737 :
738 : //_______________________________________________________________
739 : void AliQA::UnSet(QABIT_t bit)
740 : {
741 : // UnSet the status bit of the current detector in the current module
742 :
743 0 : UnSetStatusBit(fDet, fTask, bit) ;
744 0 : }
745 :
746 : //_______________________________________________________________
747 : void AliQA::UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit)
748 : {
749 : // UnSet the status bit for a given detector and a given task
750 :
751 0 : CheckRange(det) ;
752 0 : CheckRange(tsk) ;
753 0 : CheckRange(bit) ;
754 :
755 0 : ULong_t offset = Offset(tsk) ;
756 0 : ULong_t status = GetStatus(det) ;
757 0 : offset+= bit ;
758 0 : status = status & 0 << offset ;
759 0 : SetStatus(det, status) ;
760 0 : }
|
