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