STEER/AliQA.cxx

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