Fixes for bug #49914: Compilation breaks in trunk, and bug #48629: Trunk cannot read...
[u/mrichter/AliRoot.git] / STEER / AliQA.cxx
index 47365f1..c24360d 100644 (file)
@@ -48,7 +48,7 @@
 ClassImp(AliQA)
 AliQA    * AliQA::fgQA                   = 0x0 ;
 TFile    * AliQA::fgQADataFile           = 0x0 ;   
-TString    AliQA::fgQADataFileName       = "QA" ;  // will transform into Det.QA.run.root  
+TString    AliQA::fgQADataFileName       = "QA" ;  // will transform into Det.QA.run.cycle.root  
 TFile    * AliQA::fgQARefFile            = 0x0 ;   
 TString    AliQA::fgQARefDirName              = "" ; 
 TString    AliQA::fgQARefFileName        = "QA.root" ;
@@ -58,137 +58,106 @@ TString    AliQA::fgQAResultFileName     = "QA.root" ;
 TString    AliQA::fgDetNames[]           = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD",
                                             "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT", "Global", "CORR"} ;   
 TString    AliQA::fgGRPPath              = "GRP/GRP/Data" ; 
+TString    AliQA::fgRTNames[]            = {"UNKNOWN", "AUTO_TEST", "CALIBRATION", "CALIBRATION_PULSER", "CHANNEL_DELAY_TUNING", "COSMIC", 
+                                                                                                                                                                               "COSMICS", "DAQ_FO_UNIF_SCAN", "DAQ_GEN_DAC_SCAN", "DAQ_MEAN_TH_SCAN", "DAQ_MIN_TH_SCAN", 
+                                                                                                                                                                               "DAQ_NOISY_PIX_SCAN", "DAQ_PIX_DELAY_SCAN", "DAQ_UNIFORMITY_SCAN", "DCS_FO_UNIF_SCAN", 
+                                                                                                                                                                               "DCS_MEAN_TH_SCAN", "DCS_MIN_TH_SCAN", "DCS_PIX_DELAY_SCAN", "DCS_UNIFORMITY_SCAN", 
+                                                                                                                                                                               "DDL_TEST", "GAIN", "PEDESTAL", "INJECTOR",  "LASER", "MONTECARLO", "NOISE", "NOISY_PIX_SCAN", 
+                                                                                                                                                                               "PHYSICS", "PULSER", "STANDALONE", "STANDALONE_BC", "STANDALONE_CENTRAL", "STANDALONE_COSMIC", 
+                                                                                                                                                                               "STANDALONE_EMD", "STANDALONE_LASER", "STANDALONE_MB", "STANDALONE_PEDESTAL", 
+                                                                                                                                                                               "STANDALONE_SEMICENTRAL", "STANDALONE_PULSER" } ;   
 TString       AliQA::fgTaskNames[]       = {"Raws", "Hits", "SDigits", "Digits", "RecPoints", "TrackSegments", "RecParticles", "ESDs"} ;   
-const TString AliQA::fgkLabLocalFile     = "file://"  ; 
-const TString AliQA::fgkLabLocalOCDB     = "local://" ;  
-const TString AliQA::fgkLabAliEnOCDB     = "alien://" ;  
-const TString AliQA::fgkRefFileName      = "QA.root" ; 
-const TString AliQA::fgkQAName           = "QA"  ; 
-const TString AliQA::fgkQACorrNtName     = "CorrQA" ;  
-const TString AliQA::fgkRefOCDBDirName   = "QA"  ; 
-TString AliQA::fgRefDataDirName                 = ""  ; 
-const TString AliQA::fgkQARefOCDBDefault = "alien://folder=/alice/QA/20"  ; 
-const TString AliQA::fgkExpert           = "Expert" ; 
-const UInt_t  AliQA::fgkExpertBit        = 16 ; 
-const UInt_t  AliQA::fgkQABit            = 17 ; 
+const TString AliQA::fkgLabLocalFile     = "file://"  ; 
+const TString AliQA::fkgLabLocalOCDB     = "local://" ;  
+const TString AliQA::fkgLabAliEnOCDB     = "alien://" ;  
+const TString AliQA::fkgRefFileName      = "QA.root" ; 
+const TString AliQA::fkgQAName           = "QA"  ; 
+const TString AliQA::fkgQACorrNtName     = "CorrQA" ;  
+const TString AliQA::fkgRefOCDBDirName   = "Ref"  ; 
+TString AliQA::fkgRefDataDirName              = ""  ; 
+const TString AliQA::fkgQARefOCDBDefault = "alien://folder=/alice/QA/20"  ; 
+const TString AliQA::fkgExpert           = "Expert" ; 
+const UInt_t  AliQA::fkgExpertBit        = 16 ; 
+const UInt_t  AliQA::fkgQABit            = 17 ; 
 
 //____________________________________________________________________________
 AliQA::AliQA() : 
   TNamed("", ""), 
   fNdet(kNDET), 
-  fNEventSpecies(AliRecoParam::kNSpecies), 
-  fLengthQA(fNdet*fNEventSpecies),
-  fQA(new ULong_t[fLengthQA]), 
+  fQA(new ULong_t[fNdet]), 
   fDet(kNULLDET),
-  fTask(kNULLTASK), 
-  fEventSpecie(AliRecoParam::kDefault), 
-  fEventSpecies(new Bool_t[fNEventSpecies])
+  fTask(kNULLTASK)
+       
 {
   // default constructor
-  memset(fQA,0,fLengthQA*sizeof(ULong_t));
-  memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+  // beware singleton: not to be used
+  
+  for (Int_t index = 0 ; index < fNdet ; index++) 
+       fQA[index] = 0 ; 
 }
 
 //____________________________________________________________________________
 AliQA::AliQA(const AliQA& qa) :
   TNamed(qa),
   fNdet(qa.fNdet), 
-  fNEventSpecies(qa.fNEventSpecies), 
-  fLengthQA(qa.fLengthQA),
-  fQA(new ULong_t[fLengthQA]), 
+  fQA(qa.fQA), 
   fDet(qa.fDet),
-  fTask(qa.fTask), 
-  fEventSpecie(qa.fEventSpecie), 
-  fEventSpecies(new Bool_t[fNEventSpecies])
+  fTask(qa.fTask)
 { 
   // cpy ctor
-  memcpy(fQA,qa.fQA,fLengthQA*sizeof(ULong_t));
-  memcpy(fEventSpecies,qa.fEventSpecies,fNEventSpecies*sizeof(Bool_t));
 }
 
 //_____________________________________________________________________________
 AliQA& AliQA::operator = (const AliQA& qa)
 {
-  // assignment operator
-  if(&qa != this) {
-    TNamed::operator=(qa);
-    fNdet          = qa.fNdet;
-    fNEventSpecies = qa.fNEventSpecies; 
-    fLengthQA      = qa.fLengthQA;
-
-    if(fQA) delete [] fQA;
-    fQA = new ULong_t[fLengthQA];
-    memcpy(fQA,qa.fQA,fLengthQA*sizeof(ULong_t));
-
-    fDet = qa.fDet;
-    fTask = qa.fTask;
-    fEventSpecie = qa.fEventSpecie; 
-    if(fEventSpecies) delete [] fEventSpecies;
-    fEventSpecies = new Bool_t[fNEventSpecies];
-    memcpy(fEventSpecies,qa.fEventSpecies,fNEventSpecies*sizeof(Bool_t));
-  }  
-  return *this;
-}
+// assignment operator
 
-//_______________________________________________________________
-AliQA::AliQA(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es) :
-TNamed("QA", "Quality Assurance status"),
-fNdet(kNDET), 
-fNEventSpecies(eslength), 
-fLengthQA(qalength),
-fQA(new ULong_t[fLengthQA]), 
-fDet(kNULLDET),
-fTask(kNULLTASK), 
-fEventSpecie(AliRecoParam::kDefault), 
-fEventSpecies(new Bool_t[fNEventSpecies])
-{
-  // constructor to be used
-  memcpy(fQA, qa, fLengthQA*sizeof(ULong_t));
-  memcpy(fEventSpecies, es, fNEventSpecies*sizeof(Bool_t));
+  this->~AliQA();
+  new(this) AliQA(qa);
+  return *this;
 }
 
 //_______________________________________________________________
 AliQA::AliQA(const DETECTORINDEX_t det) :
   TNamed("QA", "Quality Assurance status"),
-  fNdet(kNDET), 
-  fNEventSpecies(AliRecoParam::kNSpecies), 
-  fLengthQA(fNdet*fNEventSpecies),
-  fQA(new ULong_t[fLengthQA]), 
+  fNdet(kNDET),  
+  fQA(new ULong_t[fNdet]), 
   fDet(det),
-  fTask(kNULLTASK), 
-  fEventSpecie(AliRecoParam::kDefault), 
-  fEventSpecies(new Bool_t[fNEventSpecies])
+  fTask(kNULLTASK) 
 {
   // constructor to be used
-  if (! CheckRange(det) ) fDet = kNULLDET ; 
-  memset(fQA,0,fLengthQA*sizeof(ULong_t));
-  memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+  if (! CheckRange(det) ) {
+    fDet = kNULLDET ; 
+    return ;
+  } 
+  Int_t index ; 
+  for (index = 0; index < fNdet; index++) 
+    fQA[index] = 0 ; 
 }
   
 //_______________________________________________________________
 AliQA::AliQA(const ALITASK_t tsk) :
-  TNamed("QA", "Quality Assurance status"),
-  fNdet(kNDET), 
-  fNEventSpecies(AliRecoParam::kNSpecies), 
-  fLengthQA(fNdet*fNEventSpecies),
-  fQA(new ULong_t[fLengthQA]), 
+  TNamed("QA", "Quality Assurance status"), 
+  fNdet(kNDET),
+  fQA(new ULong_t[fNdet]), 
   fDet(kNULLDET),
-  fTask(tsk), 
-  fEventSpecie(AliRecoParam::kDefault), 
-  fEventSpecies(new Bool_t[fNEventSpecies])
+  fTask(tsk)
 {
   // constructor to be used in the AliRoot module (SIM, REC, ESD or ANA)
-  if (! CheckRange(tsk) ) fTask = kNULLTASK ; 
-  memset(fQA,0,fLengthQA*sizeof(ULong_t));
-  memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+  if (! CheckRange(tsk) ) {
+    fTask = kNULLTASK ; 
+    return ;
+  } 
+  Int_t index ; 
+  for (index = 0; index < fNdet; index++) 
+    fQA[index] = 0 ; 
 }
 
 //____________________________________________________________________________
 AliQA::~AliQA() 
 {
   // dtor  
-  delete [] fQA;
-  delete [] fEventSpecies;
+  delete[] fQA ;
 }
 
 //_______________________________________________________________
@@ -213,7 +182,7 @@ Bool_t AliQA::CheckFatal() const
   Bool_t rv = kFALSE ;
   Int_t index ;
   for (index = 0; index < kNDET ; index++)
-    rv = rv || IsSet(DETECTORINDEX_t(index), fTask, fEventSpecie, kFATAL) ;
+    rv = rv || IsSet(DETECTORINDEX_t(index), fTask, kFATAL) ;
   return rv ;
 }
 
@@ -249,35 +218,10 @@ Bool_t AliQA::CheckRange(QABIT_t bit) const
   return rv ;
 }
 
-//_______________________________________________________________
-Bool_t AliQA::CheckRange(AliRecoParam::EventSpecie_t es) const
-{ 
-  // check if bit is in given bit range: 0-kNBit
-  Bool_t rv = kFALSE ; 
-  switch (es) {
-    case AliRecoParam::kDefault: 
-      rv = kTRUE ; 
-      break ; 
-    case AliRecoParam::kLowMult: 
-      rv = kTRUE ; 
-      break ; 
-    case AliRecoParam::kHighMult: 
-      rv = kTRUE ; 
-      break ; 
-    case AliRecoParam::kCosmic: 
-      rv = kTRUE ; 
-      break ; 
-    case AliRecoParam::kCalib: 
-      rv = kTRUE ; 
-      break ; 
-  }
-  if (!rv)
-    AliFatal(Form("Event Specie %d is not valid", es)) ;
-  return rv ;
-}
+
 
 //_______________________________________________________________
-const char * AliQA::GetAliTaskName(ALITASK_t tsk)
+char * AliQA::GetAliTaskName(ALITASK_t tsk)
 {
        // returns the char name corresponding to module index
        TString tskName ;
@@ -303,11 +247,11 @@ const char * AliQA::GetAliTaskName(ALITASK_t tsk)
                        tsk = kNULLTASK ; 
                        break ;
        }
-       return tskName.Data() ;
+       return Form("%s", tskName.Data()) ;
 }
 
 //_______________________________________________________________
-const char * AliQA::GetBitName(QABIT_t bit) const
+char * AliQA::GetBitName(QABIT_t bit) const
 {
        // returns the char name corresponding to bit 
        TString bitName ;
@@ -330,7 +274,7 @@ const char * AliQA::GetBitName(QABIT_t bit) const
                        bit = kNULLBit ; 
                        break ;
        }
-       return bitName.Data() ;
+       return Form("%s", bitName.Data()) ; 
 }
 
 //_______________________________________________________________
@@ -360,7 +304,7 @@ const char * AliQA::GetDetName(Int_t det)
 }
 
 //_______________________________________________________________
-TFile * AliQA::GetQADataFile(const char * name, Int_t run) 
+TFile * AliQA::GetQADataFile(const char * name, const Int_t run) 
 {
   // opens the file to store the detectors Quality Assurance Data Maker results
        const char * temp = Form("%s.%s.%d.root", name, fgQADataFileName.Data(), run) ; 
@@ -412,8 +356,8 @@ TFile * AliQA::GetQAResultFile()
        fgQAResultFile = 0x0 ; 
 //     if (!fgQAResultFile) { 
                TString dirName(fgQAResultDirName) ; 
-               if ( dirName.Contains(fgkLabLocalFile)) 
-                       dirName.ReplaceAll(fgkLabLocalFile, "") ;
+               if ( dirName.Contains(fkgLabLocalFile)) 
+                       dirName.ReplaceAll(fkgLabLocalFile, "") ;
                TString fileName(dirName + fgQAResultFileName) ; 
                TString opt("") ; 
                if ( !gSystem->AccessPathName(fileName) )
@@ -430,6 +374,25 @@ TFile * AliQA::GetQAResultFile()
 }
 
 //_______________________________________________________________
+const TString AliQA::GetRunTypeName(RUNTYPE_t rt) 
+{ 
+       TString rv("Invalid Run Type") ;        
+       if ( rt == kNULLTYPE ) {
+               rv = "Known RUN_TYPE are: \n" ; 
+               for (Int_t index = 0 ; index < kNTYPE; index++) {
+                       rv += Form("%2d -- %s\n", index, fgRTNames[index].Data()) ;  
+               }
+               printf("%s", rv.Data()) ; 
+               return "" ; 
+       }
+       else {
+               if ( rt > kNULLTYPE && rt < kNTYPE )
+                       rv = fgRTNames[rt] ; 
+       }
+       return rv ; 
+}
+
+//_______________________________________________________________
 AliQA::TASKINDEX_t AliQA::GetTaskIndex(const char * name) 
 {
        // returns the detector index corresponding to a given name
@@ -445,44 +408,32 @@ AliQA::TASKINDEX_t AliQA::GetTaskIndex(const char * name)
 }
 
 //_______________________________________________________________
-Bool_t AliQA::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, Int_t ies, QABIT_t bit) const 
-{
-  // Checks is the requested bit is set
-   
-  const AliRecoParam::EventSpecie_t es = AliRecoParam::Convert(ies) ; 
-  return IsSet(det, tsk, es, bit) ; 
-  
-}  
-
-//_______________________________________________________________
-Bool_t AliQA::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) const
+Bool_t AliQA::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit) const
 {
   // Checks is the requested bit is set
        
   CheckRange(det) ; 
   CheckRange(tsk) ;
   CheckRange(bit) ;
-  CheckRange(es) ;
        
   ULong_t offset = Offset(tsk) ;
-  ULong_t status = GetStatus(det, es) ;
+  ULong_t status = GetStatus(det) ;
   offset+= bit ;
   status = (status & 1 << offset) != 0 ;
   return status ;
 }
 
 //_______________________________________________________________
-Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) const
+Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk) const
 {
   // Checks is the requested bit is set
        
   CheckRange(det) ; 
   CheckRange(tsk) ;
-  CheckRange(es) ;
        
   ULong_t offset = Offset(tsk) ;
-  ULong_t status = GetStatus(det, es) ;
-       ULong_t st = 0 ; 
+  ULong_t status = GetStatus(det) ;
+       UShort_t st = 0 ; 
        for ( Int_t bit = 0 ; bit < kNBIT ; bit++) {
                offset+= bit ;
                st += (status & 1 << offset) != 0 ;             
@@ -493,15 +444,14 @@ Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSp
                return kTRUE ;
 }
 //_______________________________________________________________
-Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es) const
+Bool_t AliQA::IsSetAny(DETECTORINDEX_t det) const
 {
   // Checks is the requested bit is set
        
   CheckRange(det) ; 
-  CheckRange(es) ; 
        
-       ULong_t status = GetStatus(det, es) ;
-       ULong_t st = 0 ; 
+       ULong_t status = GetStatus(det) ;
+       UShort_t st = 0 ; 
        for ( Int_t tsk = 0 ; tsk < kNTASK ; tsk++) {
                ULong_t offset = Offset(ALITASK_t(tsk)) ;
                for ( Int_t bit = 0 ; bit < kNBIT ; bit++) {
@@ -518,24 +468,9 @@ Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es) cons
 //_______________________________________________________________
 AliQA * AliQA::Instance()
 {
-  // Get an instance of the singleton. The only authorized way to call the ctor
+  // Get an instance of the singleton.
+  // Object must have been instantiated with Instance(ALITASK) first
 
-  if ( ! fgQA) {
-    TFile * f = GetQAResultFile() ; 
-    fgQA = dynamic_cast<AliQA *>(f->Get("QA")) ; 
-    if ( ! fgQA ) 
-      fgQA = new AliQA() ;
-  }    
-  return fgQA ;
-}
-
-//_______________________________________________________________
-AliQA * AliQA::Instance(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es)
-{
-  // Get an instance of the singleton. The only authorized way to call the ctor
-  
-  if ( ! fgQA) 
-    fgQA = new AliQA(qalength, qa, eslength, es) ;
   return fgQA ;
 }
 
@@ -557,7 +492,7 @@ AliQA * AliQA::Instance(const DETECTORINDEX_t det)
 //_______________________________________________________________
 AliQA * AliQA::Instance(const ALITASK_t tsk)
 {
-  // Get an instance of the singleton. The only authorized way to call the ctor
+  // get an instance of the singleton.
 
   if ( ! fgQA)
     switch (tsk) {
@@ -617,10 +552,8 @@ void AliQA::Merge(TCollection * list) {
                                TIter next(list) ;
                                AliQA * qa ; 
                                while ( (qa = (AliQA*)next() ) ) {
-          for (Int_t es = 0 ; es < fNEventSpecies ; es++) {
-            if (qa->IsSet(DETECTORINDEX_t(det), ALITASK_t(task), es, QABIT_t(bit)))
-              Set(QABIT_t(bit), es) ; 
-          }
+                                       qa->IsSet(DETECTORINDEX_t(det), ALITASK_t(task), QABIT_t(bit)) ;
+                                       Set(QABIT_t(bit)) ; 
                                } // qa list
                        } // bit
                } // task
@@ -661,26 +594,11 @@ ULong_t AliQA::Offset(ALITASK_t tsk) const
 }
 
 //_______________________________________________________________
-void AliQA::ResetStatus(DETECTORINDEX_t det) 
-{ 
-  // reset the status of det for all event specie
-  for (Int_t es = 0 ; es < fNEventSpecies ; es++)
-    fQA[det*fNdet+es] = 0 ; 
-}
-
-//_______________________________________________________________
-void AliQA::Set(QABIT_t bit, Int_t ies)
+void AliQA::Set(QABIT_t bit)
 {
-  // Set the status bit of the current detector in the current module and for the current event specie 
-   Set(bit, AliRecoParam::Convert(ies)) ;
-}
-
-//_______________________________________________________________
-void AliQA::Set(QABIT_t bit, AliRecoParam::EventSpecie_t es)
-{
-  // Set the status bit of the current detector in the current module and for the current event specie 
+  // Set the status bit of the current detector in the current module
   
-  SetStatusBit(fDet, fTask, es, bit) ;
+  SetStatusBit(fDet, fTask, bit) ;
 }
 
 //_____________________________________________________________________________
@@ -689,12 +607,12 @@ void AliQA::SetQARefStorage(const char * name)
        // Set the root directory where the QA reference data are stored
 
        fgQARefDirName = name ; 
-       if ( fgQARefDirName.Contains(fgkLabLocalFile) )
-               fgQARefFileName =  fgkRefFileName ; 
-       else if ( fgQARefDirName.Contains(fgkLabLocalOCDB) )
-               fgQARefFileName =  fgkQAName ; 
-       else if ( fgQARefDirName.Contains(fgkLabAliEnOCDB) )
-               fgQARefFileName =  fgkQAName ; 
+       if ( fgQARefDirName.Contains(fkgLabLocalFile) )
+               fgQARefFileName =  fkgRefFileName ; 
+       else if ( fgQARefDirName.Contains(fkgLabLocalOCDB) )
+               fgQARefFileName =  fkgQAName ; 
+       else if ( fgQARefDirName.Contains(fkgLabAliEnOCDB) )
+               fgQARefFileName =  fkgQAName ; 
 
   else {
          printf("ERROR: %s is an invalid storage definition\n", name) ; 
@@ -706,70 +624,72 @@ void AliQA::SetQARefStorage(const char * name)
 }
 
 //_____________________________________________________________________________
+void AliQA::SetQARefDataDirName(const char * name) 
+{
+  // Set the lower level directory name where reference data are found
+  TString test(name) ; 
+  RUNTYPE_t rt = kNULLTYPE ; 
+  for (Int_t index = 0; index < kNTYPE; index++) {
+    if (test.CompareTo(fgRTNames[index]) == 0) {
+      rt = (RUNTYPE_t) index ; 
+      break ; 
+    } 
+       }
+       
+       if (rt == kNULLTYPE) {
+      printf("AliQA::SetQARefDataDirName: %s is an unknown RUN TYPE name\n", name) ; 
+      return ; 
+       }
+       SetQARefDataDirName(rt) ; 
+}
+
+//_____________________________________________________________________________
 void AliQA::SetQAResultDirName(const char * name)
 {
   // Set the root directory where to store the QA status object
 
   fgQAResultDirName.Prepend(name) ; 
   printf("AliQA::SetQAResultDirName: QA results are in  %s\n", fgQAResultDirName.Data()) ;
-  if ( fgQAResultDirName.Contains(fgkLabLocalFile)) 
-    fgQAResultDirName.ReplaceAll(fgkLabLocalFile, "") ;
+  if ( fgQAResultDirName.Contains(fkgLabLocalFile)) 
+    fgQAResultDirName.ReplaceAll(fkgLabLocalFile, "") ;
   fgQAResultFileName.Prepend(fgQAResultDirName) ;
 }
 
 //_______________________________________________________________
-void AliQA::SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit)
+void AliQA::SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit)
 {
  // Set the status bit for a given detector and a given task
 
   CheckRange(det) ;
   CheckRange(tsk) ;
   CheckRange(bit) ;
-  CheckRange(es) ;
 
   ULong_t offset = Offset(tsk) ;
-  ULong_t status = GetStatus(det, es) ;
+  ULong_t status = GetStatus(det) ;
   offset+= bit ;
   status = status | 1 << offset ;
-  SetStatus(det, es, status) ;
+  SetStatus(det, status) ;
 }
 
 //_______________________________________________________________
-void AliQA::Show(DETECTORINDEX_t det) const 
-{ 
-  // dispplay the QA status word
-  if ( det == kNULLDET) 
-    det = fDet ;  
-  for (Int_t ies = 0 ; ies < fNEventSpecies ; ies++) {
-    const Bool_t what = IsEventSpecieSet(ies) ;
-    if ( what )
-      ShowStatus(det, kNULLTASK, AliRecoParam::Convert(ies)) ; 
-  }
-}
-
-//_______________________________________________________________
-void AliQA::ShowAll() const 
+void AliQA::ShowAll() const
 {
   // dispplay the QA status word
   Int_t index ;
   for (index = 0 ; index < kNDET ; index++) {
                for (Int_t tsk = kRAW ; tsk < kNTASK ; tsk++) {
-      for (Int_t ies = 0 ; ies < fNEventSpecies ; ies++) {
-        const Bool_t what = IsEventSpecieSet(ies) ;
-        if ( what )
-          ShowStatus(DETECTORINDEX_t(index), ALITASK_t(tsk), AliRecoParam::Convert(ies)) ;
-      }
-    }
+                       ShowStatus(DETECTORINDEX_t(index), ALITASK_t(tsk)) ;
+               }
        }
 }
 
 //_______________________________________________________________
-void AliQA::ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) const
+void AliQA::ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk) const
 {
        // Prints the full QA status of a given detector
        CheckRange(det) ;
-       CheckRange(es) ;
-       ULong_t status = GetStatus(det, es) ;
+       ULong_t status = GetStatus(det) ;
        ULong_t tskStatus[kNTASK] ; 
        tskStatus[kRAW] = status & 0x0000f ;
        tskStatus[kSIM] = status & 0x000f0 ;
@@ -777,60 +697,52 @@ void AliQA::ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSp
        tskStatus[kESD] = status & 0x0f000 ;
        tskStatus[kANA] = status & 0xf0000 ;
 
-       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), 
+       AliInfo(Form("====> QA Status for %8s raw =0x%x, sim=0x%x, rec=0x%x, esd=0x%x, ana=0x%x", GetDetName(det).Data(), 
                                 tskStatus[kRAW], tskStatus[kSIM], tskStatus[kREC], tskStatus[kESD], tskStatus[kANA] )) ;
        if (tsk == kNULLTASK) {
                for (Int_t itsk = kRAW ; itsk < kNTASK ; itsk++) {
-                       ShowASCIIStatus(es, det, ALITASK_t(itsk), tskStatus[itsk]) ; 
+                       ShowASCIIStatus(det, ALITASK_t(itsk), tskStatus[itsk]) ; 
                } 
        } else {
-                       ShowASCIIStatus(es, det, tsk, tskStatus[tsk]) ; 
+                       ShowASCIIStatus(det, tsk, tskStatus[tsk]) ; 
        }
 }
 
 //_______________________________________________________________
-void AliQA::ShowASCIIStatus(AliRecoParam::EventSpecie_t es, DETECTORINDEX_t det, ALITASK_t tsk, const ULong_t status) const 
+void AliQA::ShowASCIIStatus(DETECTORINDEX_t det, ALITASK_t tsk, const ULong_t status) const 
 {
        // print the QA status in human readable format
        TString text; 
        for (Int_t bit = kINFO ; bit < kNBIT ; bit++) {
-               if (IsSet(det, tsk, es, QABIT_t(bit))) {
+               if (IsSet(det, tsk, QABIT_t(bit))) {
                        text = GetBitName(QABIT_t(bit)) ; 
                        text += " " ; 
                }
        }
        if (! text.IsNull())
-               printf("           %8s %8s %4s 0x%4lx, Problem signalled: %8s \n", AliRecoParam::GetEventSpecieName(es), GetDetName(det).Data(), GetAliTaskName(tsk), status, text.Data()) ; 
+               printf("           %8s %4s 0x%4lx, Problem signalled: %8s \n", GetDetName(det).Data(), GetAliTaskName(tsk), status, text.Data()) ; 
 }
 
 //_______________________________________________________________
-void AliQA::UnSet(QABIT_t bit, Int_t ies)
-{
-       // UnSet the status bit of the current detector in the current module
-               UnSet(bit, AliRecoParam::Convert(ies)) ;
-}
-
-//_______________________________________________________________
-void AliQA::UnSet(QABIT_t bit, AliRecoParam::EventSpecie_t es)
+void AliQA::UnSet(QABIT_t bit)
 {
        // UnSet the status bit of the current detector in the current module
        
-       UnSetStatusBit(fDet, fTask, es, bit) ;
+       UnSetStatusBit(fDet, fTask, bit) ;
 }
 
 //_______________________________________________________________
-void AliQA::UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit)
+void AliQA::UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit)
 {
        // UnSet the status bit for a given detector and a given task
        
        CheckRange(det) ;
        CheckRange(tsk) ;
        CheckRange(bit) ;
-       CheckRange(es) ;
        
        ULong_t offset = Offset(tsk) ;
-       ULong_t status = GetStatus(det, es) ;
+       ULong_t status = GetStatus(det) ;
        offset+= bit ;
        status = status & 0 << offset ;
-       SetStatus(det, es, status) ;
-}
+       SetStatus(det, status) ;
+}
\ No newline at end of file