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.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::fgTaskNames[]       = {"Raws", "Hits", "SDigits", "Digits", "RecPoints", "TrackSegments", "RecParticles", "ESDs"} ;
  62 const TString AliQA::fgkLabLocalFile     = "file://"  ;
  63 const TString AliQA::fgkLabLocalOCDB     = "local://" ;
  64 const TString AliQA::fgkLabAliEnOCDB     = "alien://" ;
  65 const TString AliQA::fgkRefFileName      = "QA.root" ;
  66 const TString AliQA::fgkQAName           = "QA"  ;
  67 const TString AliQA::fgkQACorrNtName     = "CorrQA" ;
  68 const TString AliQA::fgkRefOCDBDirName   = "QA"  ;
  69 TString AliQA::fgRefDataDirName          = ""  ;
  70 const TString AliQA::fgkQARefOCDBDefault = "alien://folder=/alice/QA/20"  ;
  71 const TString AliQA::fgkExpert           = "Expert" ;
  72 const UInt_t  AliQA::fgkExpertBit        = 16 ;
  73 const UInt_t  AliQA::fgkQABit            = 17 ;
  74
  75 //____________________________________________________________________________
  76 AliQA::AliQA() :
  77   TNamed("", ""),
  78   fNdet(kNDET),
  79   fNEventSpecies(AliRecoParam::kNSpecies),
  80   fLengthQA(fNdet*fNEventSpecies),
  81   fQA(new ULong_t[fLengthQA]),
  82   fDet(kNULLDET),
  83   fTask(kNULLTASK),
  84   fEventSpecie(AliRecoParam::kDefault),
  85   fEventSpecies(new Bool_t[fNEventSpecies])
  86 {
  87   // default constructor
  88   memset(fQA,0,fLengthQA);
  89   memset(fEventSpecies,kFALSE,fNEventSpecies);
  90 }
  91
  92 //____________________________________________________________________________
  93 AliQA::AliQA(const AliQA& qa) :
  94   TNamed(qa),
  95   fNdet(qa.fNdet),
  96   fNEventSpecies(qa.fNEventSpecies),
  97   fLengthQA(qa.fLengthQA),
  98   fQA(new ULong_t[fLengthQA]),
  99   fDet(qa.fDet),
 100   fTask(qa.fTask),
 101   fEventSpecie(qa.fEventSpecie),
 102   fEventSpecies(new Bool_t[fNEventSpecies])
 103 {
 104   // cpy ctor
 105   memcpy(fQA,qa.fQA,fLengthQA*sizeof(ULong_t));
 106   memcpy(fEventSpecies,qa.fEventSpecies,fNEventSpecies*sizeof(Bool_t));
 107 }
 108
 109 //_____________________________________________________________________________
 110 AliQA& AliQA::operator = (const AliQA& qa)
 111 {
 112   // assignment operator
 113   if(&qa != this) {
 114     TNamed::operator=(qa);
 115     fNdet          = qa.fNdet;
 116     fNEventSpecies = qa.fNEventSpecies;
 117     fLengthQA      = qa.fLengthQA;
 118
 119     if(fQA) delete [] fQA;
 120     fQA = new ULong_t[fLengthQA];
 121     memcpy(fQA,qa.fQA,fLengthQA*sizeof(ULong_t));
 122
 123     fDet = qa.fDet;
 124     fTask = qa.fTask;
 125     fEventSpecie = qa.fEventSpecie;
 126     if(fEventSpecies) delete [] fEventSpecies;
 127     fEventSpecies = new Bool_t[fNEventSpecies];
 128     memcpy(fEventSpecies,qa.fEventSpecies,fNEventSpecies*sizeof(Bool_t));
 129   }
 130   return *this;
 131 }
 132
 133 //_______________________________________________________________
 134 AliQA::AliQA(const DETECTORINDEX_t det) :
 135   TNamed("QA", "Quality Assurance status"),
 136   fNdet(kNDET),
 137   fNEventSpecies(AliRecoParam::kNSpecies),
 138   fLengthQA(fNdet*fNEventSpecies),
 139   fQA(new ULong_t[fLengthQA]),
 140   fDet(det),
 141   fTask(kNULLTASK),
 142   fEventSpecie(AliRecoParam::kDefault),
 143   fEventSpecies(new Bool_t[fNEventSpecies])
 144 {
 145   // constructor to be used
 146   if (! CheckRange(det) ) fDet = kNULLDET ;
 147   memset(fQA,0,fLengthQA);
 148   memset(fEventSpecies,kFALSE,fNEventSpecies);
 149 }
 150
 151 //_______________________________________________________________
 152 AliQA::AliQA(const ALITASK_t tsk) :
 153   TNamed("QA", "Quality Assurance status"),
 154   fNdet(kNDET),
 155   fNEventSpecies(AliRecoParam::kNSpecies),
 156   fLengthQA(fNdet*fNEventSpecies),
 157   fQA(new ULong_t[fLengthQA]),
 158   fDet(kNULLDET),
 159   fTask(tsk),
 160   fEventSpecie(AliRecoParam::kDefault),
 161   fEventSpecies(new Bool_t[fNEventSpecies])
 162 {
 163   // constructor to be used in the AliRoot module (SIM, REC, ESD or ANA)
 164   if (! CheckRange(tsk) ) fTask = kNULLTASK ;
 165   memset(fQA,0,fLengthQA);
 166   memset(fEventSpecies,kFALSE,fNEventSpecies);
 167 }
 168
 169 //____________________________________________________________________________
 170 AliQA::~AliQA()
 171 {
 172   // dtor
 173   delete [] fQA;
 174   delete [] fEventSpecies;
 175 }
 176
 177 //_______________________________________________________________
 178 void AliQA::Close()
 179 {
 180         // close the open files
 181         if (fgQADataFile)
 182                 if (fgQADataFile->IsOpen())
 183                         fgQADataFile->Close() ;
 184         if (fgQAResultFile)
 185                 if (fgQAResultFile->IsOpen())
 186                         fgQAResultFile->Close() ;
 187         if (fgQARefFile)
 188                 if (fgQARefFile->IsOpen())
 189                         fgQARefFile->Close() ;
 190 }
 191
 192 //_______________________________________________________________
 193 Bool_t AliQA::CheckFatal() const
 194 {
 195   // check if any FATAL status is set
 196   Bool_t rv = kFALSE ;
 197   Int_t index ;
 198   for (index = 0; index < kNDET ; index++)
 199     rv = rv || IsSet(DETECTORINDEX_t(index), fTask, fEventSpecie, kFATAL) ;
 200   return rv ;
 201 }
 202
 203 //_______________________________________________________________
 204 Bool_t AliQA::CheckRange(DETECTORINDEX_t det) const
 205 {
 206   // check if detector is in given detector range: 0-kNDET
 207
 208   Bool_t rv = ( det < 0 || det > kNDET )  ? kFALSE : kTRUE ;
 209   if (!rv)
 210     AliFatal(Form("Detector index %d is out of range: 0 <= index <= %d", det, kNDET)) ;
 211   return rv ;
 212 }
 213
 214 //_______________________________________________________________
 215 Bool_t AliQA::CheckRange(ALITASK_t task) const
 216 {
 217   // check if task is given taskk range: 0:kNTASK
 218   Bool_t rv = ( task < kRAW || task > kNTASK )  ? kFALSE : kTRUE ;
 219   if (!rv)
 220     AliFatal(Form("Module index %d is out of range: 0 <= index <= %d", task, kNTASK)) ;
 221   return rv ;
 222 }
 223
 224 //_______________________________________________________________
 225 Bool_t AliQA::CheckRange(QABIT_t bit) const
 226 {
 227   // check if bit is in given bit range: 0-kNBit
 228
 229   Bool_t rv = ( bit < 0 || bit > kNBIT )  ? kFALSE : kTRUE ;
 230   if (!rv)
 231     AliFatal(Form("Status bit %d is out of range: 0 <= bit <= %d", bit, kNBIT)) ;
 232   return rv ;
 233 }
 234
 235 //_______________________________________________________________
 236 Bool_t AliQA::CheckRange(AliRecoParam::EventSpecie_t es) const
 237 {
 238   // check if bit is in given bit range: 0-kNBit
 239   Bool_t rv = kFALSE ;
 240   switch (es) {
 241     case AliRecoParam::kDefault:
 242       rv = kTRUE ;
 243       break ;
 244     case AliRecoParam::kLowMult:
 245       rv = kTRUE ;
 246       break ;
 247     case AliRecoParam::kHighMult:
 248       rv = kTRUE ;
 249       break ;
 250     case AliRecoParam::kCosmic:
 251       rv = kTRUE ;
 252       break ;
 253     case AliRecoParam::kCalib:
 254       rv = kTRUE ;
 255       break ;
 256   }
 257   if (!rv)
 258     AliFatal(Form("Event Specie %d is not valid", es)) ;
 259   return rv ;
 260 }
 261
 262 //_______________________________________________________________
 263 const char * AliQA::GetAliTaskName(ALITASK_t tsk)
 264 {
 265         // returns the char name corresponding to module index
 266         TString tskName ;
 267         switch (tsk) {
 268                 case kNULLTASK:
 269                         break ;
 270                 case kRAW:
 271                         tskName = "RAW" ;
 272                         break ;
 273                 case kSIM:
 274                         tskName = "SIM" ;
 275                         break ;
 276                 case kREC:
 277                         tskName = "REC" ;
 278                         break ;
 279                 case kESD:
 280                         tskName = "ESD" ;
 281                         break ;
 282                 case kANA:
 283                         tskName = "ANA" ;
 284                         break ;
 285                 default:
 286                         tsk = kNULLTASK ;
 287                         break ;
 288         }
 289         return tskName.Data() ;
 290 }
 291
 292 //_______________________________________________________________
 293 const char * AliQA::GetBitName(QABIT_t bit) const
 294 {
 295         // returns the char name corresponding to bit
 296         TString bitName ;
 297         switch (bit) {
 298                 case kNULLBit:
 299                         break ;
 300                 case kINFO:
 301                         bitName = "INFO" ;
 302                         break ;
 303                 case kWARNING:
 304                         bitName = "WARNING" ;
 305                         break ;
 306                 case kERROR:
 307                         bitName = "ERROR" ;
 308                         break ;
 309                 case kFATAL:
 310                         bitName = "FATAL" ;
 311                         break ;
 312                 default:
 313                         bit = kNULLBit ;
 314                         break ;
 315         }
 316         return bitName.Data() ;
 317 }
 318
 319 //_______________________________________________________________
 320 AliQA::DETECTORINDEX_t AliQA::GetDetIndex(const char * name)
 321 {
 322         // returns the detector index corresponding to a given name
 323         TString sname(name) ;
 324         DETECTORINDEX_t rv = kNULLDET ;
 325         for (Int_t det = 0; det < kNDET ; det++) {
 326                 if ( GetDetName(det) == sname ) {
 327                         rv = DETECTORINDEX_t(det) ;
 328                         break ;
 329                 }
 330         }
 331         return rv ;
 332 }
 333
 334 //_______________________________________________________________
 335 const char * AliQA::GetDetName(Int_t det)
 336 {
 337         // returns the detector name corresponding to a given index (needed in a loop)
 338
 339         if ( det >= 0 &&  det < kNDET)
 340                 return (fgDetNames[det]).Data() ;
 341         else
 342                 return NULL ;
 343 }
 344
 345 //_______________________________________________________________
 346 TFile * AliQA::GetQADataFile(const char * name, Int_t run)
 347 {
 348   // opens the file to store the detectors Quality Assurance Data Maker results
 349         const char * temp = Form("%s.%s.%d.root", name, fgQADataFileName.Data(), run) ;
 350         TString opt ;
 351         if (! fgQADataFile ) {
 352                 if  (gSystem->AccessPathName(temp))
 353                         opt = "NEW" ;
 354                 else
 355                         opt = "UPDATE" ;
 356                 fgQADataFile = TFile::Open(temp, opt.Data()) ;
 357         } else {
 358                 if ( strcmp(temp, fgQADataFile->GetName()) != 0 ) {
 359                         fgQADataFile = dynamic_cast<TFile *>(gROOT->FindObject(temp)) ;
 360                         if ( !fgQADataFile ) {
 361                                 if  (gSystem->AccessPathName(temp))
 362                                         opt = "NEW" ;
 363                                 else
 364                                         opt = "UPDATE" ;
 365                                 fgQADataFile = TFile::Open(temp, opt.Data()) ;
 366                         }
 367                 }
 368   }
 369         return fgQADataFile ;
 370 }
 371
 372 //_____________________________________________________________________________
 373 TFile * AliQA::GetQADataFile(const char * fileName)
 374 {
 375   // Open if necessary the Data file and return its pointer
 376
 377   if (!fgQADataFile)
 378         if (!fileName)
 379                 fileName = AliQA::GetQADataFileName() ;
 380         if  (!gSystem->AccessPathName(fileName)) {
 381                 fgQADataFile =  TFile::Open(fileName) ;
 382         } else {
 383                 printf("File %s not found", fileName) ;
 384                 exit(1) ;
 385         }
 386   return fgQADataFile ;
 387 }
 388
 389 //_______________________________________________________________
 390 TFile * AliQA::GetQAResultFile()
 391 {
 392   // opens the file to store the  Quality Assurance Data Checker results
 393         if (fgQAResultFile)
 394                 fgQAResultFile->Close() ;
 395         fgQAResultFile = 0x0 ;
 396 //      if (!fgQAResultFile) {
 397                 TString dirName(fgQAResultDirName) ;
 398                 if ( dirName.Contains(fgkLabLocalFile))
 399                         dirName.ReplaceAll(fgkLabLocalFile, "") ;
 400                 TString fileName(dirName + fgQAResultFileName) ;
 401                 TString opt("") ;
 402                 if ( !gSystem->AccessPathName(fileName) )
 403                         opt = "UPDATE" ;
 404                 else {
 405                         if ( gSystem->AccessPathName(dirName) )
 406                                 gSystem->mkdir(dirName) ;
 407                         opt = "NEW" ;
 408                 }
 409                 fgQAResultFile = TFile::Open(fileName, opt) ;
 410 //      }
 411
 412         return fgQAResultFile ;
 413 }
 414
 415 //_______________________________________________________________
 416 AliQA::TASKINDEX_t AliQA::GetTaskIndex(const char * name)
 417 {
 418         // returns the detector index corresponding to a given name
 419         TString sname(name) ;
 420         TASKINDEX_t rv = kNULLTASKINDEX ;
 421         for (Int_t tsk = 0; tsk < kNTASKINDEX ; tsk++) {
 422                 if ( GetTaskName(tsk) == sname ) {
 423                         rv = TASKINDEX_t(tsk) ;
 424                         break ;
 425                 }
 426         }
 427         return rv ;
 428 }
 429
 430 //_______________________________________________________________
 431 Bool_t AliQA::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, Int_t ies, QABIT_t bit) const
 432 {
 433   // Checks is the requested bit is set
 434
 435   const AliRecoParam::EventSpecie_t es = AliRecoParam::Convert(ies) ;
 436   return IsSet(det, tsk, es, bit) ;
 437
 438 }
 439
 440 //_______________________________________________________________
 441 Bool_t AliQA::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) const
 442 {
 443   // Checks is the requested bit is set
 444
 445   CheckRange(det) ;
 446   CheckRange(tsk) ;
 447   CheckRange(bit) ;
 448   CheckRange(es) ;
 449
 450   ULong_t offset = Offset(tsk) ;
 451   ULong_t status = GetStatus(det, es) ;
 452   offset+= bit ;
 453   status = (status & 1 << offset) != 0 ;
 454   return status ;
 455 }
 456
 457 //_______________________________________________________________
 458 Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) const
 459 {
 460   // Checks is the requested bit is set
 461
 462   CheckRange(det) ;
 463   CheckRange(tsk) ;
 464   CheckRange(es) ;
 465
 466   ULong_t offset = Offset(tsk) ;
 467   ULong_t status = GetStatus(det, es) ;
 468         ULong_t st = 0 ;
 469         for ( Int_t bit = 0 ; bit < kNBIT ; bit++) {
 470                 offset+= bit ;
 471                 st += (status & 1 << offset) != 0 ;
 472         }
 473         if ( st == 0 )
 474                 return kFALSE ;
 475         else
 476                 return kTRUE ;
 477 }
 478 //_______________________________________________________________
 479 Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es) const
 480 {
 481   // Checks is the requested bit is set
 482
 483   CheckRange(det) ;
 484   CheckRange(es) ;
 485
 486         ULong_t status = GetStatus(det, es) ;
 487         ULong_t st = 0 ;
 488         for ( Int_t tsk = 0 ; tsk < kNTASK ; tsk++) {
 489                 ULong_t offset = Offset(ALITASK_t(tsk)) ;
 490                 for ( Int_t bit = 0 ; bit < kNBIT ; bit++) {
 491                         offset+= bit ;
 492                         st += (status & 1 << offset) != 0 ;
 493                 }
 494         }
 495         if ( st == 0 )
 496                 return kFALSE ;
 497         else
 498                 return kTRUE ;
 499 }
 500
 501 //_______________________________________________________________
 502 AliQA * AliQA::Instance()
 503 {
 504   // Get an instance of the singleton. The only authorized way to call the ctor
 505
 506   if ( ! fgQA) {
 507     TFile * f = GetQAResultFile() ;
 508     fgQA = dynamic_cast<AliQA *>(f->Get("QA")) ;
 509     if ( ! fgQA )
 510       fgQA = new AliQA() ;
 511   }
 512   return fgQA ;
 513 }
 514
 515 //_______________________________________________________________
 516 AliQA * AliQA::Instance(const DETECTORINDEX_t det)
 517 {
 518   // Get an instance of the singleton. The only authorized way to call the ctor
 519
 520   if ( ! fgQA) {
 521     TFile * f = GetQAResultFile() ;
 522         fgQA = dynamic_cast<AliQA *>(f->Get("QA")) ;
 523     if ( ! fgQA )
 524                 fgQA = new AliQA(det) ;
 525   }
 526   fgQA->Set(det) ;
 527   return fgQA ;
 528 }
 529
 530 //_______________________________________________________________
 531 AliQA * AliQA::Instance(const ALITASK_t tsk)
 532 {
 533   // Get an instance of the singleton. The only authorized way to call the ctor
 534
 535   if ( ! fgQA)
 536     switch (tsk) {
 537     case kNULLTASK:
 538       break ;
 539         case kRAW:
 540       fgQA = new AliQA(tsk) ;
 541       break ;
 542         case kSIM:
 543       fgQA = new AliQA(tsk) ;
 544       break ;
 545     case kREC:
 546       printf("fgQA = gAlice->GetQA()") ;
 547       break ;
 548     case kESD:
 549       printf("fgQA = dynamic_cast<AliQA *> (esdFile->Get(\"QA\")") ;
 550       break ;
 551     case kANA:
 552       printf("fgQA = dynamic_cast<AliQA *> (esdFile->Get(\"QA\")") ;
 553       break ;
 554     case kNTASK:
 555       break ;
 556     }
 557   if (fgQA)
 558     fgQA->Set(tsk) ;
 559   return fgQA ;
 560 }
 561
 562 //_______________________________________________________________
 563 AliQA *  AliQA::Instance(const TASKINDEX_t tsk)
 564 {
 565         // get an instance of the singleton.
 566
 567         ALITASK_t index = kNULLTASK ;
 568
 569         if ( tsk == kRAWS )
 570                 index = kRAW ;
 571         else if (tsk < kDIGITS)
 572                 index = kSIM ;
 573         else if (tsk < kRECPARTICLES)
 574                 index = kREC ;
 575         else if (tsk == kESDS)
 576                 index = kESD ;
 577
 578         return Instance(index) ;
 579 }
 580
 581 //_______________________________________________________________
 582 void AliQA::Merge(TCollection * list) {
 583         // Merge the QA resuls in the list into this single AliQA object
 584
 585         for (Int_t det = 0 ; det < kNDET ; det++) {
 586                 Set(DETECTORINDEX_t(det)) ;
 587                 for (Int_t task = 0 ; task < kNTASK ; task++) {
 588                         Set(ALITASK_t(task)) ;
 589                         for (Int_t bit = 0 ; bit < kNBIT ; bit++) {
 590                                 TIter next(list) ;
 591                                 AliQA * qa ;
 592                                 while ( (qa = (AliQA*)next() ) ) {
 593           for (Int_t es = 0 ; es < fNEventSpecies ; es++) {
 594             if (qa->IsSet(DETECTORINDEX_t(det), ALITASK_t(task), es, QABIT_t(bit)))
 595               Set(QABIT_t(bit), es) ;
 596           }
 597                                 } // qa list
 598                         } // bit
 599                 } // task
 600         } // detector
 601 }
 602
 603 //_______________________________________________________________
 604 ULong_t AliQA::Offset(ALITASK_t tsk) const
 605 {
 606   // Calculates the bit offset for a given module (SIM, REC, ESD, ANA)
 607
 608   CheckRange(tsk) ;
 609
 610   ULong_t offset = 0 ;
 611   switch (tsk) {
 612   case kNULLTASK:
 613     break ;
 614   case kRAW:
 615     offset+= 0 ;
 616     break ;
 617   case kSIM:
 618     offset+= 4 ;
 619     break ;
 620   case kREC:
 621     offset+= 8 ;
 622     break ;
 623   case kESD:
 624     offset+= 12 ;
 625     break ;
 626   case kANA:
 627     offset+= 16 ;
 628     break ;
 629   case kNTASK:
 630     break ;
 631   }
 632
 633   return offset ;
 634 }
 635
 636 //_______________________________________________________________
 637 void AliQA::ResetStatus(DETECTORINDEX_t det)
 638 {
 639   // reset the status of det for all event specie
 640   for (Int_t es = 0 ; es < fNEventSpecies ; es++)
 641     fQA[det*fNdet+es] = 0 ;
 642 }
 643
 644 //_______________________________________________________________
 645 void AliQA::Set(QABIT_t bit, Int_t ies)
 646 {
 647   // Set the status bit of the current detector in the current module and for the current event specie
 648    Set(bit, AliRecoParam::Convert(ies)) ;
 649 }
 650
 651 //_______________________________________________________________
 652 void AliQA::Set(QABIT_t bit, AliRecoParam::EventSpecie_t es)
 653 {
 654   // Set the status bit of the current detector in the current module and for the current event specie
 655
 656   SetStatusBit(fDet, fTask, es, bit) ;
 657 }
 658
 659 //_____________________________________________________________________________
 660 void AliQA::SetQARefStorage(const char * name)
 661 {
 662         // Set the root directory where the QA reference data are stored
 663
 664         fgQARefDirName = name ;
 665         if ( fgQARefDirName.Contains(fgkLabLocalFile) )
 666                 fgQARefFileName =  fgkRefFileName ;
 667         else if ( fgQARefDirName.Contains(fgkLabLocalOCDB) )
 668                 fgQARefFileName =  fgkQAName ;
 669         else if ( fgQARefDirName.Contains(fgkLabAliEnOCDB) )
 670                 fgQARefFileName =  fgkQAName ;
 671
 672   else {
 673           printf("ERROR: %s is an invalid storage definition\n", name) ;
 674           fgQARefDirName  = "" ;
 675           fgQARefFileName = "" ;
 676   }
 677         TString tmp(fgQARefDirName) ; // + fgQARefFileName) ;
 678         printf("AliQA::SetQARefDir: QA references are in  %s\n", tmp.Data() ) ;
 679 }
 680
 681 //_____________________________________________________________________________
 682 void AliQA::SetQAResultDirName(const char * name)
 683 {
 684   // Set the root directory where to store the QA status object
 685
 686   fgQAResultDirName.Prepend(name) ;
 687   printf("AliQA::SetQAResultDirName: QA results are in  %s\n", fgQAResultDirName.Data()) ;
 688   if ( fgQAResultDirName.Contains(fgkLabLocalFile))
 689     fgQAResultDirName.ReplaceAll(fgkLabLocalFile, "") ;
 690   fgQAResultFileName.Prepend(fgQAResultDirName) ;
 691 }
 692
 693 //_______________________________________________________________
 694 void AliQA::SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit)
 695 {
 696  // Set the status bit for a given detector and a given task
 697
 698   CheckRange(det) ;
 699   CheckRange(tsk) ;
 700   CheckRange(bit) ;
 701   CheckRange(es) ;
 702
 703   ULong_t offset = Offset(tsk) ;
 704   ULong_t status = GetStatus(det, es) ;
 705   offset+= bit ;
 706   status = status | 1 << offset ;
 707   SetStatus(det, es, status) ;
 708 }
 709
 710 //_______________________________________________________________
 711 void AliQA::Show() const
 712 {
 713   // dispplay the QA status word
 714
 715   for (Int_t ies = 0 ; ies < fNEventSpecies ; ies++) {
 716     const Bool_t what = IsEventSpecieSet(ies) ;
 717     if ( what )
 718       ShowStatus(fDet, fTask, AliRecoParam::Convert(ies)) ;
 719   }
 720 }
 721
 722 //_______________________________________________________________
 723 void AliQA::Show(DETECTORINDEX_t det) const
 724 {
 725   // dispplay the QA status word
 726
 727   for (Int_t ies = 0 ; ies < fNEventSpecies ; ies++) {
 728     const Bool_t what = IsEventSpecieSet(ies) ;
 729     if ( what )
 730       ShowStatus(fDet, kNULLTASK, AliRecoParam::Convert(ies)) ;
 731   }
 732 }
 733
 734 //_______________________________________________________________
 735 void AliQA::ShowAll() const
 736 {
 737   // dispplay the QA status word
 738   Int_t index ;
 739   for (index = 0 ; index < kNDET ; index++) {
 740                 for (Int_t tsk = kRAW ; tsk < kNTASK ; tsk++) {
 741       for (Int_t ies = 0 ; ies < fNEventSpecies ; ies++) {
 742         const Bool_t what = IsEventSpecieSet(ies) ;
 743         if ( what )
 744           ShowStatus(DETECTORINDEX_t(index), ALITASK_t(tsk), AliRecoParam::Convert(ies)) ;
 745       }
 746     }
 747         }
 748 }
 749
 750 //_______________________________________________________________
 751 void AliQA::ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) const
 752 {
 753         // Prints the full QA status of a given detector
 754         CheckRange(det) ;
 755         CheckRange(es) ;
 756         ULong_t status = GetStatus(det, es) ;
 757         ULong_t tskStatus[kNTASK] ;
 758         tskStatus[kRAW] = status & 0x0000f ;
 759         tskStatus[kSIM] = status & 0x000f0 ;
 760         tskStatus[kREC] = status & 0x00f00 ;
 761         tskStatus[kESD] = status & 0x0f000 ;
 762         tskStatus[kANA] = status & 0xf0000 ;
 763
 764         AliInfo(Form("====> QA Status for %8s %8s raw =0x%x, sim=0x%x, rec=0x%x, esd=0x%x, ana=0x%x", GetDetName(det).Data(), AliRecoParam::GetEventSpecieName(es),
 765                                  tskStatus[kRAW], tskStatus[kSIM], tskStatus[kREC], tskStatus[kESD], tskStatus[kANA] )) ;
 766         if (tsk == kNULLTASK) {
 767                 for (Int_t itsk = kRAW ; itsk < kNTASK ; itsk++) {
 768                         ShowASCIIStatus(es, det, ALITASK_t(itsk), tskStatus[itsk]) ;
 769                 }
 770         } else {
 771                         ShowASCIIStatus(es, det, tsk, tskStatus[tsk]) ;
 772         }
 773 }
 774
 775 //_______________________________________________________________
 776 void AliQA::ShowASCIIStatus(AliRecoParam::EventSpecie_t es, DETECTORINDEX_t det, ALITASK_t tsk, const ULong_t status) const
 777 {
 778         // print the QA status in human readable format
 779         TString text;
 780         for (Int_t bit = kINFO ; bit < kNBIT ; bit++) {
 781                 if (IsSet(det, tsk, es, QABIT_t(bit))) {
 782                         text = GetBitName(QABIT_t(bit)) ;
 783                         text += " " ;
 784                 }
 785         }
 786         if (! text.IsNull())
 787                 printf("           %8s %8s %4s 0x%4lx, Problem signalled: %8s \n", AliRecoParam::GetEventSpecieName(es), GetDetName(det).Data(), GetAliTaskName(tsk), status, text.Data()) ;
 788 }
 789
 790 //_______________________________________________________________
 791 void AliQA::UnSet(QABIT_t bit, Int_t ies)
 792 {
 793         // UnSet the status bit of the current detector in the current module
 794                 UnSet(bit, AliRecoParam::Convert(ies)) ;
 795 }
 796
 797 //_______________________________________________________________
 798 void AliQA::UnSet(QABIT_t bit, AliRecoParam::EventSpecie_t es)
 799 {
 800         // UnSet the status bit of the current detector in the current module
 801
 802         UnSetStatusBit(fDet, fTask, es, bit) ;
 803 }
 804
 805 //_______________________________________________________________
 806 void AliQA::UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit)
 807 {
 808         // UnSet the status bit for a given detector and a given task
 809
 810         CheckRange(det) ;
 811         CheckRange(tsk) ;
 812         CheckRange(bit) ;
 813         CheckRange(es) ;
 814
 815         ULong_t offset = Offset(tsk) ;
 816         ULong_t status = GetStatus(det, es) ;
 817         offset+= bit ;
 818         status = status & 0 << offset ;
 819         SetStatus(det, es, status) ;
 820 }