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