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 Bool_t AliQA::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit) const
 391 {
 392   // Checks is the requested bit is set
 393
 394   CheckRange(det) ;
 395   CheckRange(tsk) ;
 396   CheckRange(bit) ;
 397
 398   ULong_t offset = Offset(tsk) ;
 399   ULong_t status = GetStatus(det) ;
 400   offset+= bit ;
 401   status = (status & 1 << offset) != 0 ;
 402   return status ;
 403 }
 404
 405 //_______________________________________________________________
 406 AliQA * AliQA::Instance()
 407 {
 408   // Get an instance of the singleton.
 409   // Object must have been instantiated with Instance(ALITASK) first
 410
 411   return fgQA ;
 412 }
 413
 414 //_______________________________________________________________
 415 AliQA * AliQA::Instance(const DETECTORINDEX_t det)
 416 {
 417   // Get an instance of the singleton. The only authorized way to call the ctor
 418
 419   if ( ! fgQA) {
 420     TFile * f = GetQAResultFile() ;
 421         fgQA = dynamic_cast<AliQA *>(f->Get("QA")) ;
 422     if ( ! fgQA )
 423                 fgQA = new AliQA(det) ;
 424   }
 425   fgQA->Set(det) ;
 426   return fgQA ;
 427 }
 428
 429 //_______________________________________________________________
 430 AliQA * AliQA::Instance(const ALITASK_t tsk)
 431 {
 432   // get an instance of the singleton.
 433
 434   if ( ! fgQA)
 435     switch (tsk) {
 436     case kNULLTASK:
 437       break ;
 438         case kRAW:
 439       fgQA = new AliQA(tsk) ;
 440       break ;
 441         case kSIM:
 442       fgQA = new AliQA(tsk) ;
 443       break ;
 444     case kREC:
 445       printf("fgQA = gAlice->GetQA()") ;
 446       break ;
 447     case kESD:
 448       printf("fgQA = dynamic_cast<AliQA *> (esdFile->Get(\"QA\")") ;
 449       break ;
 450     case kANA:
 451       printf("fgQA = dynamic_cast<AliQA *> (esdFile->Get(\"QA\")") ;
 452       break ;
 453     case kNTASK:
 454       break ;
 455     }
 456   if (fgQA)
 457     fgQA->Set(tsk) ;
 458   return fgQA ;
 459 }
 460
 461 //_______________________________________________________________
 462 AliQA *  AliQA::Instance(const TASKINDEX_t tsk)
 463 {
 464         // get an instance of the singleton.
 465
 466         ALITASK_t index = kNULLTASK ;
 467
 468         if ( tsk == kRAWS )
 469                 index = kRAW ;
 470         else if (tsk < kDIGITS)
 471                 index = kSIM ;
 472         else if (tsk < kRECPARTICLES)
 473                 index = kREC ;
 474         else if (tsk == kESDS)
 475                 index = kESD ;
 476
 477         return Instance(index) ;
 478 }
 479
 480 //_______________________________________________________________
 481 const ULong_t AliQA::Offset(ALITASK_t tsk) const
 482 {
 483   // Calculates the bit offset for a given module (SIM, REC, ESD, ANA)
 484
 485   CheckRange(tsk) ;
 486
 487   ULong_t offset = 0 ;
 488   switch (tsk) {
 489   case kNULLTASK:
 490     break ;
 491   case kRAW:
 492     offset+= 0 ;
 493     break ;
 494   case kSIM:
 495     offset+= 4 ;
 496     break ;
 497   case kREC:
 498     offset+= 8 ;
 499     break ;
 500   case kESD:
 501     offset+= 12 ;
 502     break ;
 503   case kANA:
 504     offset+= 16 ;
 505     break ;
 506   case kNTASK:
 507     break ;
 508   }
 509
 510   return offset ;
 511 }
 512
 513 //_______________________________________________________________
 514 void AliQA::Set(QABIT_t bit)
 515 {
 516   // Set the status bit of the current detector in the current module
 517
 518   SetStatusBit(fDet, fTask, bit) ;
 519 }
 520
 521 //_____________________________________________________________________________
 522 void AliQA::SetQARefStorage(const char * name)
 523 {
 524         // Set the root directory where the QA reference data are stored
 525
 526         fgQARefDirName = name ;
 527         if ( fgQARefDirName.Contains(fkgLabLocalFile) )
 528                 fgQARefFileName =  fkgRefFileName ;
 529         else if ( fgQARefDirName.Contains(fkgLabLocalOCDB) )
 530                 fgQARefFileName =  fkgQAName ;
 531         else if ( fgQARefDirName.Contains(fkgLabAliEnOCDB) )
 532                 fgQARefFileName =  fkgQAName ;
 533
 534   else {
 535           printf("ERROR: %s is an invalid storage definition\n", name) ;
 536           fgQARefDirName  = "" ;
 537           fgQARefFileName = "" ;
 538   }
 539         TString tmp(fgQARefDirName) ; // + fgQARefFileName) ;
 540         printf("AliQA::SetQARefDir: QA references are in  %s\n", tmp.Data() ) ;
 541 }
 542
 543 //_____________________________________________________________________________
 544 void AliQA::SetQARefDataDirName(const char * name)
 545 {
 546   // Set the lower level directory name where reference data are found
 547   TString test(name) ;
 548   RUNTYPE_t rt = kNULLTYPE ;
 549   for (Int_t index = 0; index < kNTYPE; index++) {
 550     if (test.CompareTo(fgRTNames[index]) == 0) {
 551       rt = (RUNTYPE_t) index ;
 552       break ;
 553     }
 554         }
 555
 556         if (rt == kNULLTYPE) {
 557       printf("AliQA::SetQARefDataDirName: %s is an unknown RUN TYPE name\n", name) ;
 558       return ;
 559         }
 560
 561         SetQARefDataDirName(rt) ;
 562 }
 563
 564 //_____________________________________________________________________________
 565 void AliQA::SetQAResultDirName(const char * name)
 566 {
 567   // Set the root directory where to store the QA status object
 568
 569   fgQAResultDirName.Prepend(name) ;
 570   printf("AliQA::SetQAResultDirName: QA results are in  %s\n", fgQAResultDirName.Data()) ;
 571   if ( fgQAResultDirName.Contains(fkgLabLocalFile))
 572     fgQAResultDirName.ReplaceAll(fkgLabLocalFile, "") ;
 573   fgQAResultFileName.Prepend(fgQAResultDirName) ;
 574 }
 575
 576 //_______________________________________________________________
 577 void AliQA::SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit)
 578 {
 579  // Set the status bit for a given detector and a given task
 580
 581   CheckRange(det) ;
 582   CheckRange(tsk) ;
 583   CheckRange(bit) ;
 584
 585   ULong_t offset = Offset(tsk) ;
 586   ULong_t status = GetStatus(det) ;
 587   offset+= bit ;
 588   status = status | 1 << offset ;
 589   SetStatus(det, status) ;
 590 }
 591
 592 //_______________________________________________________________
 593 void AliQA::ShowAll() const
 594 {
 595   // dispplay the QA status word
 596   Int_t index ;
 597   for (index = 0 ; index < kNDET ; index++) {
 598                 for (Int_t tsk = kRAW ; tsk < kNTASK ; tsk++) {
 599                         ShowStatus(DETECTORINDEX_t(index), ALITASK_t(tsk)) ;
 600                 }
 601         }
 602 }
 603
 604 //_______________________________________________________________
 605 void AliQA::ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk) const
 606 {
 607         // Prints the full QA status of a given detector
 608         CheckRange(det) ;
 609         ULong_t status = GetStatus(det) ;
 610         ULong_t tskStatus[kNTASK] ;
 611         tskStatus[kRAW] = status & 0x0000f ;
 612         tskStatus[kSIM] = status & 0x000f0 ;
 613         tskStatus[kREC] = status & 0x00f00 ;
 614         tskStatus[kESD] = status & 0x0f000 ;
 615         tskStatus[kANA] = status & 0xf0000 ;
 616
 617         AliInfo(Form("====> QA Status for %8s raw =0x%x, sim=0x%x, rec=0x%x, esd=0x%x, ana=0x%x", GetDetName(det).Data(),
 618                                  tskStatus[kRAW], tskStatus[kSIM], tskStatus[kREC], tskStatus[kESD], tskStatus[kANA] )) ;
 619         if (tsk == kNULLTASK) {
 620                 for (Int_t itsk = kRAW ; itsk < kNTASK ; itsk++) {
 621                         ShowASCIIStatus(det, ALITASK_t(itsk), tskStatus[itsk]) ;
 622                 }
 623         } else {
 624                         ShowASCIIStatus(det, tsk, tskStatus[tsk]) ;
 625         }
 626 }
 627
 628 //_______________________________________________________________
 629 void AliQA::ShowASCIIStatus(DETECTORINDEX_t det, ALITASK_t tsk, const ULong_t status) const
 630 {
 631         // print the QA status in human readable format
 632         TString text;
 633         for (Int_t bit = kINFO ; bit < kNBIT ; bit++) {
 634                 if (IsSet(det, tsk, QABIT_t(bit))) {
 635                         text = GetBitName(QABIT_t(bit)) ;
 636                         text += " " ;
 637                 }
 638         }
 639         if (! text.IsNull())
 640                 printf("           %8s %4s 0x%4x, Problem signalled: %8s \n", GetDetName(det).Data(), GetAliTaskName(tsk), status, text.Data()) ;
 641 }
 642
 643 //_______________________________________________________________
 644 void AliQA::UnSet(QABIT_t bit)
 645 {
 646         // UnSet the status bit of the current detector in the current module
 647
 648         UnSetStatusBit(fDet, fTask, bit) ;
 649 }
 650
 651 //_______________________________________________________________
 652 void AliQA::UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit)
 653 {
 654         // UnSet the status bit for a given detector and a given task
 655
 656         CheckRange(det) ;
 657         CheckRange(tsk) ;
 658         CheckRange(bit) ;
 659
 660         ULong_t offset = Offset(tsk) ;
 661         ULong_t status = GetStatus(det) ;
 662         offset+= bit ;
 663         status = status & 0 << offset ;
 664         SetStatus(det, status) ;
 665 }