coding convention for type (_t) and access of reference data from alien OCDB
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 19 Mar 2008 17:19:51 +0000 (17:19 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 19 Mar 2008 17:19:51 +0000 (17:19 +0000)
14 files changed:
STEER/AliQA.cxx
STEER/AliQA.h
STEER/AliQAChecker.cxx
STEER/AliQAChecker.h
STEER/AliQACheckerBase.cxx
STEER/AliQACheckerBase.h
STEER/AliQADataMaker.cxx
STEER/AliQADataMaker.h
STEER/AliQADataMakerRec.h
STEER/AliQADataMakerSim.cxx
STEER/AliQADataMakerSim.h
STEER/AliQADataMakerSteer.cxx
STEER/AliQADataMakerSteer.h
STEER/AliReconstruction.cxx

index e233c18ca28204c45b89da6449c571c8652112c8..fac44e481fc52bc6a87cc0d208da5a5dbe9912f1 100644 (file)
@@ -60,9 +60,9 @@ const TString AliQA::fkgLabLocalFile     = "file://"  ;
 const TString AliQA::fkgLabLocalOCDB     = "local://" ;  
 const TString AliQA::fkgLabAliEnOCDB     = "alien://" ;  
 const TString AliQA::fkgRefFileName      = "QA.root" ; 
-const TString AliQA::fkgQAOCDBDirName    = "QA"  ; 
+const TString AliQA::fkgQAName           = "QA"  ; 
 const TString AliQA::fkgRefOCDBDirName   = "Ref"  ; 
-const TString AliQA::fkgRefDataDirName   = "Data"  ; 
+TString AliQA::fkgRefDataDirName   = "Data"  ; 
 const TString AliQA::fkgQARefOCDBDefault = "alien://folder=/alice/QA/20"  ; 
 //____________________________________________________________________________
 AliQA::AliQA() : 
@@ -102,7 +102,7 @@ AliQA& AliQA::operator = (const AliQA& qa)
 }
 
 //_______________________________________________________________
-AliQA::AliQA(const DETECTORINDEX det) :
+AliQA::AliQA(const DETECTORINDEX_t det) :
   TNamed("QA", "Quality Assurance status"),
   fNdet(kNDET),  
   fQA(new ULong_t[fNdet]), 
@@ -120,13 +120,14 @@ AliQA::AliQA(const DETECTORINDEX det) :
 }
   
 //_______________________________________________________________
-AliQA::AliQA(const ALITASK tsk) :
+AliQA::AliQA(const ALITASK_t tsk) :
   TNamed("QA", "Quality Assurance status"), 
   fNdet(kNDET),
   fQA(new ULong_t[fNdet]), 
   fDet(kNULLDET),
   fTask(tsk)
 {
+       AliInfo(Form("TTTTTTTTTTTTTTTTTTTTTTT %d", tsk)) ;      
   // constructor to be used in the AliRoot module (SIM, REC, ESD or ANA)
   if (! CheckRange(tsk) ) {
     fTask = kNULLTASK ; 
@@ -166,12 +167,12 @@ const Bool_t AliQA::CheckFatal() const
   Bool_t rv = kFALSE ;
   Int_t index ;
   for (index = 0; index < kNDET ; index++)
-    rv = rv || IsSet(DETECTORINDEX(index), fTask, kFATAL) ;
+    rv = rv || IsSet(DETECTORINDEX_t(index), fTask, kFATAL) ;
   return rv ;
 }
 
 //_______________________________________________________________
-const Bool_t AliQA::CheckRange(DETECTORINDEX det) const
+const Bool_t AliQA::CheckRange(DETECTORINDEX_t det) const
 { 
   // check if detector is in given detector range: 0-kNDET
 
@@ -182,7 +183,7 @@ const Bool_t AliQA::CheckRange(DETECTORINDEX det) const
 }
 
 //_______________________________________________________________
-const Bool_t AliQA::CheckRange(ALITASK task) const
+const Bool_t AliQA::CheckRange(ALITASK_t task) const
 { 
   // check if task is given taskk range: 0:kNTASK
   Bool_t rv = ( task < kRAW || task > kNTASK )  ? kFALSE : kTRUE ;
@@ -192,7 +193,7 @@ const Bool_t AliQA::CheckRange(ALITASK task) const
 }
 
 //_______________________________________________________________
-const Bool_t AliQA::CheckRange(QABIT bit) const
+const Bool_t AliQA::CheckRange(QABIT_t bit) const
 { 
   // check if bit is in given bit range: 0-kNBit
 
@@ -205,7 +206,7 @@ const Bool_t AliQA::CheckRange(QABIT bit) const
 
 
 //_______________________________________________________________
-const char * AliQA::GetAliTaskName(ALITASK tsk)
+const char * AliQA::GetAliTaskName(ALITASK_t tsk)
 {
   // returns the char name corresponding to module index
   TString tskName ;
@@ -238,39 +239,53 @@ const char * AliQA::GetAliTaskName(ALITASK tsk)
 const char * AliQA::GetDetName(Int_t det) 
 {
        // returns the detector name corresponding to a given index (needed in a loop)
-
+       
        if ( det >= 0 &&  det < kNDET) 
                return (fgDetNames[det]).Data() ; 
        else 
                return NULL ; 
 }
 
+//_______________________________________________________________
+const AliQA::DETECTORINDEX_t AliQA::GetDetName(const char * name) 
+{
+       // returns the detector index corresponding to a given name
+       TString sname(name) ; 
+       DETECTORINDEX_t rv = kNULLDET ; 
+       for (Int_t det = 0; det < kNDET ; det++) {
+               if ( GetDetName(det) == sname ) {
+                       rv = DETECTORINDEX_t(det) ; 
+                       break ; 
+               }
+       }
+       return rv ;             
+}
+
 //_______________________________________________________________
 TFile * AliQA::GetQADataFile(const char * name, const Int_t run, const Int_t cycle) 
 {
   // opens the file to store the detectors Quality Assurance Data Maker results
-  char temp[20] ; 
-  sprintf(temp, "%s.%s.%d.%d.root", name, fgQADataFileName.Data(), run, cycle) ; 
-  TString opt ; 
-  if (! fgQADataFile ) {     
-    if  (gSystem->AccessPathName(temp))
-      opt = "NEW" ;
-    else 
-      opt = "UPDATE" ; 
-    fgQADataFile = TFile::Open(temp, opt.Data()) ;
-  } else {
-         if ( strcmp(temp, fgQADataFile->GetName()) != 0 ) {
-                 fgQADataFile = dynamic_cast<TFile *>(gROOT->FindObject(temp)) ; 
-                 if ( !fgQADataFile ) {
-                         if  (gSystem->AccessPathName(temp))
-                                 opt = "NEW" ;
-                         else 
-                                 opt = "UPDATE" ; 
-                         fgQADataFile = TFile::Open(temp, opt.Data()) ;
-                 }
-         }
+       const char * temp = Form("%s.%s.%d.%d.root", name, fgQADataFileName.Data(), run, cycle) ; 
+       TString opt ; 
+       if (! fgQADataFile ) {     
+               if  (gSystem->AccessPathName(temp))
+                       opt = "NEW" ;
+               else 
+                       opt = "UPDATE" ; 
+               fgQADataFile = TFile::Open(temp, opt.Data()) ;
+       } else {
+               if ( strcmp(temp, fgQADataFile->GetName()) != 0 ) {
+                       fgQADataFile = dynamic_cast<TFile *>(gROOT->FindObject(temp)) ; 
+                       if ( !fgQADataFile ) {
+                               if  (gSystem->AccessPathName(temp))
+                                       opt = "NEW" ;
+                               else 
+                                       opt = "UPDATE" ; 
+                               fgQADataFile = TFile::Open(temp, opt.Data()) ;
+                       }
+               }
   }
-  return fgQADataFile ; 
+       return fgQADataFile ;
 } 
 
 //_____________________________________________________________________________
@@ -317,7 +332,7 @@ TFile * AliQA::GetQAResultFile()
 }
 
 //_______________________________________________________________
-const Bool_t AliQA::IsSet(DETECTORINDEX det, ALITASK tsk, QABIT bit) const
+const Bool_t AliQA::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit) const
 {
   // Checks is the requested bit is set
 
@@ -342,7 +357,7 @@ AliQA * AliQA::Instance()
 }
 
 //_______________________________________________________________
-AliQA * AliQA::Instance(const DETECTORINDEX det)
+AliQA * AliQA::Instance(const DETECTORINDEX_t det)
 {
   // Get an instance of the singleton. The only authorized way to call the ctor
   
@@ -357,7 +372,7 @@ AliQA * AliQA::Instance(const DETECTORINDEX det)
 }
 
 //_______________________________________________________________
-AliQA * AliQA::Instance(const ALITASK tsk)
+AliQA * AliQA::Instance(const ALITASK_t tsk)
 {
   // get an instance of the singleton.
 
@@ -389,7 +404,26 @@ AliQA * AliQA::Instance(const ALITASK tsk)
 }
 
 //_______________________________________________________________
-const ULong_t AliQA::Offset(ALITASK tsk) const
+AliQA *  AliQA::Instance(const TASKINDEX_t tsk) 
+{
+       // get an instance of the singleton.
+       
+       ALITASK_t index = kNULLTASK ; 
+
+       if ( tsk == kRAWS )
+               index = kRAW ;
+       else if (tsk < kDIGITS)
+               index = kSIM ;
+       else if (tsk < kRECPARTICLES)
+               index = kREC ; 
+       else if (tsk == kESDS) 
+               index = kESD ; 
+
+       return Instance(index) ; 
+}
+
+//_______________________________________________________________
+const ULong_t AliQA::Offset(ALITASK_t tsk) const
 {
   // Calculates the bit offset for a given module (SIM, REC, ESD, ANA)
 
@@ -422,7 +456,7 @@ const ULong_t AliQA::Offset(ALITASK tsk) const
 }
 
 //_______________________________________________________________
-void AliQA::Set(QABIT bit)
+void AliQA::Set(QABIT_t bit)
 {
   // Set the status bit of the current detector in the current module
   
@@ -438,9 +472,9 @@ void AliQA::SetQARefStorage(const char * name)
        if ( fgQARefDirName.Contains(fkgLabLocalFile) )
                fgQARefFileName =  fkgRefFileName ; 
        else if ( fgQARefDirName.Contains(fkgLabLocalOCDB) )
-               fgQARefFileName =  fkgQAOCDBDirName ; 
+               fgQARefFileName =  fkgQAName ; 
        else if ( fgQARefDirName.Contains(fkgLabAliEnOCDB) )
-               fgQARefFileName =  fkgQAOCDBDirName ; 
+               fgQARefFileName =  fkgQAName ; 
 
   else {
          printf("ERROR: %s is an invalid storage definition\n", name) ; 
@@ -464,7 +498,7 @@ void AliQA::SetQAResultDirName(const char * name)
 }
 
 //_______________________________________________________________
-void AliQA::SetStatusBit(DETECTORINDEX det, ALITASK tsk, QABIT 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
 
@@ -485,11 +519,11 @@ void AliQA::ShowAll() const
   // dispplay the QA status word
   Int_t index ;
   for (index = 0 ; index < kNDET ; index++)
-    ShowStatus(DETECTORINDEX(index)) ;
+    ShowStatus(DETECTORINDEX_t(index)) ;
 }
 
 //_______________________________________________________________
-void AliQA::ShowStatus(DETECTORINDEX det) const
+void AliQA::ShowStatus(DETECTORINDEX_t det) const
 {
   // Prints the full QA status of a given detector
   CheckRange(det) ;
@@ -503,3 +537,26 @@ void AliQA::ShowStatus(DETECTORINDEX det) const
   AliInfo(Form("QA Status for %8s raw =0x%x, sim=0x%x, rec=0x%x, esd=0x%x, ana=0x%x\n", GetDetName(det).Data(), rawStatus, simStatus, recStatus, esdStatus, anaStatus )) ;
 }
 
+//_______________________________________________________________
+void AliQA::UnSet(QABIT_t bit)
+{
+       // UnSet the status bit of the current detector in the current module
+       
+       UnSetStatusBit(fDet, fTask, 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) ;
+       
+       ULong_t offset = Offset(tsk) ;
+       ULong_t status = GetStatus(det) ;
+       offset+= bit ;
+       status = status & 0 << offset ;
+       SetStatus(det, status) ;
+}
\ No newline at end of file
index 0d865949c0e0fd03d77c28b88bd172a28be41282..85c1a91ee23aa3403d010d1e924e0223f3c9605a 100644 (file)
@@ -17,76 +17,81 @@ class TFile ;
 class AliQA : public TNamed {
 public:
 
-       enum DETECTORINDEX {
+       enum DETECTORINDEX_t {
     kNULLDET=-1, kITS, kTPC, kTRD, kTOF, kPHOS, kHMPID, kEMCAL, kMUON, kFMD,
     kZDC, kPMD, kT0, kVZERO, kACORDE, kHLT, kNDET };
-       enum ALITASK {
+       enum ALITASK_t {
     kNULLTASK=-1, kRAW, kSIM, kREC, kESD, kANA, kNTASK };
-       enum QABIT {
+       enum QABIT_t {
     kNULLBit=-1, kINFO, kWARNING, kERROR, kFATAL, kNBIT };
   
-       enum TASKINDEX {
+       enum TASKINDEX_t {
     kRAWS, kHITS, kSDIGITS, kDIGITS, kRECPOINTS, kTRACKSEGMENTS, kRECPARTICLES, kESDS, kNTASKINDEX };
   
        // Creators - destructors
        AliQA(); // beware singleton, not to be used
-       AliQA(const ALITASK tsk) ;
-       AliQA(const DETECTORINDEX det) ;
+       AliQA(const ALITASK_t tsk) ;
+       AliQA(const DETECTORINDEX_t det) ;
        AliQA(const AliQA& qa) ;   
        AliQA& operator = (const AliQA& qa) ;
        virtual ~AliQA();
  
        static  AliQA *   Instance() ;
-       static  AliQA *   Instance(const DETECTORINDEX det) ;
-       static  AliQA *   Instance(const ALITASK tsk) ;
+       static  AliQA *   Instance(const DETECTORINDEX_t det) ;
+       static  AliQA *   Instance(const ALITASK_t tsk) ;
+       static  AliQA *   Instance(const TASKINDEX_t tsk) ;
        const Bool_t           CheckFatal() const ;
        static void            Close() ; 
-       static const char *    GetAliTaskName(ALITASK tsk) ;
+       static const char *    GetAliTaskName(ALITASK_t tsk) ;
     static const TString   GetLabLocalFile() { return fkgLabLocalFile ; } 
     static const TString   GetLabLocalOCDB() { return fkgLabLocalOCDB ; } 
     static const TString   GetLabAliEnOCDB() { return fkgLabAliEnOCDB ; } 
-       static const TString   GetDetName(DETECTORINDEX det) { return fgDetNames[det] ; }
-       static const TString   GetTaskName(TASKINDEX tsk) { return fgTaskNames[tsk] ; }
+       static const TString   GetDetName(DETECTORINDEX_t det) { return fgDetNames[det] ; }
+       static const DETECTORINDEX_t AliQA::GetDetName(const char * name) ; 
+       static const TString   GetTaskName(TASKINDEX_t tsk) { return fgTaskNames[tsk] ; }
        static const char *    GetDetName(Int_t det) ;
        static const char *    GetQADataFileName() { return fgQADataFileName.Data() ; }
        static TFile *         GetQADataFile(const char * name, const Int_t run, const Int_t cycle) ; 
        static TFile *             GetQADataFile(const char * fileName) ;
+       static const char *    GetQAName() { return fkgQAName ; } 
        static TFile *         GetQAResultFile() ; 
        static const char  *   GetQAResultFileName() { return (fgQAResultDirName + fgQAResultFileName).Data() ; }
        static const char  *   GetQARefDefaultStorage() { return fkgQARefOCDBDefault.Data() ; }
        static const char  *   GetQARefFileName() { return fgQARefFileName ; }
        static const char  *   GetQARefStorage() { return fgQARefDirName.Data() ; }
-       static const char  *   GetQAOCDBDirName() { return fkgQAOCDBDirName.Data() ; }
        static const char  *   GetRefOCDBDirName() { return fkgRefOCDBDirName.Data() ; }
        static const char  *   GetRefDataDirName() { return fkgRefDataDirName.Data() ; }
-       const Bool_t           IsSet(DETECTORINDEX det, ALITASK tsk, QABIT bit) const ;
-       void                   Set(QABIT bit) ;
+       const Bool_t           IsSet(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit) const ;
+       void                   Set(QABIT_t bit) ;
        static void                        SetQAResultDirName(const char * name) ; 
        static void            SetQARefStorage(const char * name) ; 
-       void                   Show() const { ShowStatus(fDet) ; }
+       static void            SetQARefDataDirName( const char * name) { fkgRefDataDirName = name ; }
+    void                   Show() const { ShowStatus(fDet) ; }
        void                   ShowAll() const ;
+       void                   UnSet(QABIT_t bit) ;
 
 private:      
 
-       const Bool_t         CheckRange(DETECTORINDEX det) const ;
-       const Bool_t         CheckRange(ALITASK tsk) const ;
-       const Bool_t         CheckRange(QABIT bit) const ;
-       const char *         GetBitName(QABIT bit) const ;
-       const ULong_t        GetStatus(DETECTORINDEX det) const  { return fQA[det] ;}
+       const Bool_t         CheckRange(DETECTORINDEX_t det) const ;
+       const Bool_t         CheckRange(ALITASK_t tsk) const ;
+       const Bool_t         CheckRange(QABIT_t bit) const ;
+       const char *         GetBitName(QABIT_t bit) const ;
+       const ULong_t        GetStatus(DETECTORINDEX_t det) const  { return fQA[det] ;}
        void                 Finish() const ;  
-       const ULong_t        Offset(ALITASK tsk) const ;
-       virtual void         ShowStatus(DETECTORINDEX det) const ;
-       void                 ResetStatus(DETECTORINDEX det) { fQA[det] = 0 ; }
-       void                 Set(DETECTORINDEX det) { fDet = det ;}
-       void                 Set(ALITASK tsk) { fTask = tsk ; AliDebug(1, Form("Ready to set QA status in %s", GetAliTaskName(tsk) )) ; }
-       void                 SetStatus(DETECTORINDEX det, UShort_t status) { fQA[det] = status ; }
-       void                 SetStatusBit(DETECTORINDEX det, ALITASK tsk, QABIT bit) ;
+       const ULong_t        Offset(ALITASK_t tsk) const ;
+       virtual void         ShowStatus(DETECTORINDEX_t det) const ;
+       void                 ResetStatus(DETECTORINDEX_t det) { fQA[det] = 0 ; }
+       void                 Set(DETECTORINDEX_t det) { fDet = det ;}
+       void                 Set(ALITASK_t tsk) { fTask = tsk ; AliDebug(1, Form("Ready to set QA status in %s", GetAliTaskName(tsk) )) ; }
+       void                 SetStatus(DETECTORINDEX_t det, UShort_t status) { fQA[det] = status ; }
+       void                 SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit) ;
+       void                 UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit) ;
 
        static AliQA *fgQA                                          ; // pointer to the instance of the singleton
        Int_t                fNdet                          ; // number of detectors
        ULong_t    *         fQA                            ; //[fNdet] the status word 4 bits for SIM, REC, ESD, ANA each
-       DETECTORINDEX        fDet                           ; //!  the current detector (ITS, TPC, ....)
-       ALITASK              fTask                      ; //!  the current environment (SIM, REC, ESD, ANA)
+       DETECTORINDEX_t      fDet                           ; //!  the current detector (ITS, TPC, ....)
+       ALITASK_t            fTask                      ; //!  the current environment (SIM, REC, ESD, ANA)
        static TString       fgDetNames[]           ; //! list of detector names   
        static TFile *       fgQADataFile           ; //! the output file where the quality assurance maker store their results
        static TString       fgQADataFileName   ; //! the name of the file where the quality assurance maker store their results
@@ -101,9 +106,9 @@ private:
        static const TString fkgLabLocalOCDB    ; //! label to identify a file as local OCDB 
        static const TString fkgLabAliEnOCDB    ; //! label to identify a file as AliEn OCDB 
        static const TString fkgRefFileName     ; //! name of Reference File Name 
-       static const TString fkgQAOCDBDirName   ; //! name of Reference directory name in OCDB          
+       static const TString fkgQAName          ; //! name of QA object 
        static const TString fkgRefOCDBDirName  ; //! name of Reference directory name in OCDB          
-       static const TString fkgRefDataDirName  ; //! name of Reference directory name in OCDB for data         
+       static       TString fkgRefDataDirName  ; //! name of Reference directory name in OCDB for data         
        static const TString fkgQARefOCDBDefault; //! default storage for QA in OCDB 
 
  ClassDef(AliQA,1)  //ALICE Quality Assurance Object
index e9f883d4d4ad991469f27825385d7dfd333fa4b8..749dac46dad905faa5471a36482caaadad64ef14 100644 (file)
@@ -23,6 +23,7 @@
 
 #include "AliCDBEntry.h"
 #include "AliCDBManager.h"
+#include "AliCDBStorage.h"
 #include "AliLog.h"
 #include "AliModule.h" 
 #include "AliQA.h"
@@ -132,7 +133,7 @@ void AliQAChecker::GetRefSubDir(const char * det, const char * task, TDirectory
        dirFile = NULL ; 
        dirOCDB = NULL ; 
        TString refStorage(AliQA::GetQARefStorage()) ; 
-       refStorage += AliQA::GetQARefFileName() ;
+       //refStorage += AliQA::GetQARefFileName() ;
        if (refStorage.Contains(AliQA::GetLabLocalFile())) {    
                refStorage.ReplaceAll(AliQA::GetLabLocalFile(), "") ; 
                if ( fRefFile ) 
@@ -153,13 +154,16 @@ void AliQAChecker::GetRefSubDir(const char * det, const char * task, TDirectory
                }  
        } else if (refStorage.Contains(AliQA::GetLabLocalOCDB()) || refStorage.Contains(AliQA::GetLabAliEnOCDB())) {    
                AliCDBManager* man = AliCDBManager::Instance() ; 
-               if ( ! man->IsDefaultStorageSet() ) {
-                       man->SetDefaultStorage(AliQA::GetQARefDefaultStorage()) ; 
-                       man->SetSpecificStorage(Form("%s/*", AliQA::GetQAOCDBDirName()), AliQA::GetQARefStorage()) ; 
+               if ( man->IsDefaultStorageSet() ) { 
+                       TString temp(AliQA::GetQARefStorage()) ;  
+                       if ( ! temp.Contains(man->GetDefaultStorage()->GetBaseFolder() ) ) {
+                               man->SetDefaultStorage(AliQA::GetQARefStorage()) ; 
+                               man->SetSpecificStorage("*", AliQA::GetQARefStorage()) ;
+                       }
                }
                char detOCDBDir[20] ; 
-               sprintf(detOCDBDir, "%s/%s/%s", AliQA::GetQAOCDBDirName(), det, AliQA::GetRefOCDBDirName()) ; 
-               AliCDBEntry * entry = man->Get(detOCDBDir, 0) ; //FIXME 0 --> RUN NUMBER
+               sprintf(detOCDBDir, "%s/%s/%s", det, AliQA::GetRefOCDBDirName(), AliQA::GetRefDataDirName()) ; 
+               AliCDBEntry * entry = man->Get(detOCDBDir, man->GetRun()) ;
                if (entry) {
                        TList * listDetQAD = dynamic_cast<TList *>(entry->GetObject()) ;
                        if ( listDetQAD ) 
@@ -221,7 +225,7 @@ Bool_t AliQAChecker::Run(const char * fileName)
                AliInfo(Form("QA checker found for %s", detName.Data())) ; 
       if (!qac)
                AliFatal(Form("QA checker not found for %s", detName.Data())) ; 
-      AliQA::ALITASK index = AliQA::kNULLTASK ; 
+      AliQA::ALITASK_t index = AliQA::kNULLTASK ; 
       if ( taskName == AliQA::GetTaskName(AliQA::kHITS) ) 
                index = AliQA::kSIM ; 
       if ( taskName == AliQA::GetTaskName(AliQA::kSDIGITS) ) 
@@ -236,7 +240,7 @@ Bool_t AliQAChecker::Run(const char * fileName)
                index = AliQA::kREC ; 
       if ( taskName == AliQA::GetTaskName(AliQA::kESDS) ) 
                index = AliQA::kESD ; 
-      qac->Init(AliQA::DETECTORINDEX(det)) ; 
+      qac->Init(AliQA::DETECTORINDEX_t(det)) ; 
 
          TDirectory * refDir    = NULL ; 
          TObjArray * refOCDBDir = NULL ;       
@@ -262,7 +266,7 @@ Bool_t AliQAChecker::Run(const char * fileName)
 }
 
 //_____________________________________________________________________________
-Bool_t AliQAChecker::Run(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task, TObjArray * list)
+Bool_t AliQAChecker::Run(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, TObjArray * list)
 {
   // run the Quality Assurance Checker for detector det, for task task starting from data in list
 
@@ -272,7 +276,7 @@ Bool_t AliQAChecker::Run(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task, TObjAr
   if (!qac)
        AliError(Form("QA checker not found for %s", AliQA::GetDetName(det).Data())) ; 
   
-  AliQA::ALITASK index = AliQA::kNULLTASK ; 
+  AliQA::ALITASK_t index = AliQA::kNULLTASK ; 
   if ( task == AliQA::kRAWS ) 
                index = AliQA::kRAW ; 
   else if ( task == AliQA::kHITS ) 
index 012eedd6933aee33b9a8f50e57a60a7f46190d0a..2d0f78f5b74d6594ad9f7c128a7e2c9913ca89e7 100644 (file)
@@ -38,7 +38,7 @@ public:
 //  void                   SetRefDirName(const char * name) ; 
 
   virtual Bool_t Run(const char * fileName = NULL) ;
-  virtual Bool_t Run(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task, TObjArray * list);
+  virtual Bool_t Run(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, TObjArray * list);
 
 private:
 
index 7965fcdbebd94a9dbe28a28221d8e1983552f187..071eccd86945506aca7f27cb7dbc8fefa66e33eb 100644 (file)
@@ -80,46 +80,46 @@ const Double_t AliQACheckerBase::Check()
   // Compares all the histograms stored in the directory
   // With reference histograms either in a file of in OCDB  
 
-   Double_t test = 0.0  ;
-   Int_t count = 0 ; 
-
-   if (!fDataSubDir)  
-     test = 1. ; // nothing to check
-   else 
-     if (!fRefSubDir && !fRefOCDBSubDir)
-       test = -1 ; // no reference data
-     else {
-                TList * keyList = fDataSubDir->GetListOfKeys() ; 
-                TIter next(keyList) ; 
-                TKey * key ;
-                count = 0 ; 
-                while ( (key = static_cast<TKey *>(next())) ) {
-                        TObject * odata = fRefSubDir->Get(key->GetName()) ; 
-                        if ( odata->IsA()->InheritsFrom("TH1") ) {
-                                TH1 * hdata = static_cast<TH1*>(odata) ;
-                                TH1 * href = NULL ; 
-                                if (fRefSubDir) 
-                                        href  = static_cast<TH1*>(fRefSubDir->Get(key->GetName())) ;
-                                else if (fRefOCDBSubDir) {
-                                        href  = static_cast<TH1*>(fRefOCDBSubDir->FindObject(key->GetName())) ;
-                                }
-                                if (!href) 
-                                        test = -1 ; // no reference data ; 
-                                else {
-                                        Double_t rv =  DiffK(hdata, href) ;
-                                        AliInfo(Form("%s ->Test = %f", hdata->GetName(), rv)) ; 
-                                        test += rv ; 
-                                        count++ ; 
-                                }
-                        } else
-                                AliError(Form("%s Is a Classname that cannot be processed", key->GetClassName())) ;
-                }
-        } 
+       Double_t test = 0.0  ;
+       Int_t count = 0 ; 
+
+       if (!fDataSubDir)  
+               test = 1. ; // nothing to check
+       else 
+               if (!fRefSubDir && !fRefOCDBSubDir)
+                       test = -1 ; // no reference data
+               else {
+                       TList * keyList = fDataSubDir->GetListOfKeys() ; 
+                       TIter next(keyList) ; 
+                       TKey * key ;
+                       count = 0 ; 
+                       while ( (key = static_cast<TKey *>(next())) ) {
+                               TObject * odata = fRefSubDir->Get(key->GetName()) ; 
+                               if ( odata->IsA()->InheritsFrom("TH1") ) {
+                                       TH1 * hdata = static_cast<TH1*>(odata) ;
+                                       TH1 * href = NULL ; 
+                                       if (fRefSubDir) 
+                                               href  = static_cast<TH1*>(fRefSubDir->Get(key->GetName())) ;
+                                       else if (fRefOCDBSubDir) {
+                                               href  = static_cast<TH1*>(fRefOCDBSubDir->FindObject(key->GetName())) ;
+                                       }
+                                       if (!href) 
+                                               test = -1 ; // no reference data ; 
+                                       else {
+                                               Double_t rv =  DiffK(hdata, href) ;
+                                               AliInfo(Form("%s ->Test = %f", hdata->GetName(), rv)) ; 
+                                               test += rv ; 
+                                               count++ ; 
+                                       }
+                               } else
+                                       AliError(Form("%s Is a Classname that cannot be processed", key->GetClassName())) ;
+                       }
+               
        
-   if (count != 0) 
-     test /= count ;
+       if (count != 0) 
+               test /= count ;
    
-   return test ; 
+       return test ;
 }  
 
 //____________________________________________________________________________
@@ -128,39 +128,39 @@ const Double_t AliQACheckerBase::Check(TObjArray * list)
   // Performs a basic checking
   // Compares all the histograms in the list
 
-   Double_t test = 0.0  ;
-   Int_t count = 0 ; 
-
-   if (list->GetEntries() == 0)  
-     test = 1. ; // nothing to check
-   else {
-     if (!fRefSubDir)
-       test = -1 ; // no reference data
-     else {
-       TIter next(list) ; 
-       TH1 * hdata ;
-       count = 0 ; 
-       while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
-               if ( hdata) { 
-                       TH1 * href = NULL ; 
-                       if (fRefSubDir) 
-                               href  = static_cast<TH1*>(fRefSubDir->Get(hdata->GetName())) ;
-                       else if (fRefOCDBSubDir)
-                               href  = static_cast<TH1*>(fRefOCDBSubDir->FindObject(hdata->GetName())) ;
-                  if (!href) 
-                          test = -1 ; // no reference data ; 
-                  else {
-                          Double_t rv =  DiffK(hdata, href) ;
-                          AliInfo(Form("%s ->Test = %f", hdata->GetName(), rv)) ; 
-                          test += rv ; 
-                          count++ ; 
-                  }
-               } 
-               else
-                       AliError("Data type cannot be processed") ;
-          }
-        }
-   }
+       Double_t test = 0.0  ;
+       Int_t count = 0 ; 
+
+       if (list->GetEntries() == 0)  
+               test = 1. ; // nothing to check
+       else {
+               if (!fRefSubDir)
+                       test = -1 ; // no reference data
+               else {
+                       TIter next(list) ; 
+                       TH1 * hdata ;
+                       count = 0 ; 
+                       while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
+                               if ( hdata) { 
+                                       TH1 * href = NULL ; 
+                                       if (fRefSubDir) 
+                                               href  = static_cast<TH1*>(fRefSubDir->Get(hdata->GetName())) ;
+                                       else if (fRefOCDBSubDir)
+                                               href  = static_cast<TH1*>(fRefOCDBSubDir->FindObject(hdata->GetName())) ;
+                                       if (!href) 
+                                               test = -1 ; // no reference data ; 
+                                       else {
+                                               Double_t rv =  DiffK(hdata, href) ;
+                                               AliInfo(Form("%s ->Test = %f", hdata->GetName(), rv)) ; 
+                                               test += rv ; 
+                                               count++ ; 
+                                       }
+                               
+                               else
+                                       AliError("Data type cannot be processed") ;
+                       }
+               }
+       }
        if (count != 0) 
                test /= count ;
        return test ;
@@ -191,13 +191,13 @@ const Double_t AliQACheckerBase::DiffK(const TH1 * href, const TH1 * hin) const
 }
 
 //____________________________________________________________________________ 
-void AliQACheckerBase::Init(const AliQA::DETECTORINDEX det)
+void AliQACheckerBase::Init(const AliQA::DETECTORINDEX_t det)
 {
   AliQA::Instance(det) ; 
 }
  
 //____________________________________________________________________________
-void AliQACheckerBase::Run(AliQA::ALITASK index, TObjArray * list) 
+void AliQACheckerBase::Run(AliQA::ALITASK_t index, TObjArray * list) 
 { 
   AliDebug(1, Form("Processing %s", AliQA::GetAliTaskName(index))) ; 
 
index b87eda0844df6cfd120dc7edf1961e65976aed0c..c956b90bf0bc47b8a1bc21793a5eda5c62757898 100644 (file)
@@ -33,8 +33,8 @@ public:
   AliQACheckerBase& operator = (const AliQACheckerBase& qac) ;
   virtual ~AliQACheckerBase() {;} // dtor
 
-  void   Init(const AliQA::DETECTORINDEX det) ; 
-  void   Run(AliQA::ALITASK tsk, TObjArray * list=0x0); 
+  void   Init(const AliQA::DETECTORINDEX_t det) ; 
+  void   Run(AliQA::ALITASK_t tsk, TObjArray * list=0x0); 
   void   SetRefandData(TDirectory * ref, TObjArray * refOCDB, TDirectory * data=NULL) { fRefSubDir = ref ;  fRefOCDBSubDir = refOCDB, fDataSubDir = data ; }
 
 protected:
index 56ec5800efce74bd2ae14af837867db9b4a00dc6..dcd0746222df53c52388b96815940296bfaa332d 100644 (file)
@@ -86,11 +86,24 @@ Int_t AliQADataMaker::Add2List(TH1 * hist, const Int_t index, TObjArray * list)
        }
 }
 
+//____________________________________________________________________________
+void AliQADataMaker::DefaultEndOfDetectorCycle(AliQA::TASKINDEX_t task) 
+{
+       // this method must be oveloaded by detectors
+       // sets the QA result to Fatal
+       AliQA::Instance(AliQA::GetDetName(GetName())) ;
+       AliQA * qa = AliQA::Instance(task) ;
+       qa->Set(AliQA::kFATAL) ; 
+       AliQA::GetQAResultFile()->cd() ; 
+       qa->Write(AliQA::GetQAName(), kWriteDelete) ;   
+       AliQA::GetQAResultFile()->Close() ; 
+}
+
 //____________________________________________________________________________ 
 void AliQADataMaker::Finish() const 
 { 
-  // write to the output File
-  fOutput->Close() ; 
+       // write to the output File
+       fOutput->Close() ; 
 } 
 
 //____________________________________________________________________________ 
index d875e57231fd4969a77f7f3169e5ef74542aaa5a..331fd1cb9d2b6294209762aa7edbb7b6103a9e1e 100644 (file)
@@ -45,8 +45,8 @@ public:
        virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index)       = 0 ; 
        virtual Int_t Add2RawsList(TH1 * hist, const Int_t index)            = 0 ; 
        virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index)         = 0 ; 
-       virtual void        Exec(AliQA::TASKINDEX, TObject * data)                 = 0 ;
-       virtual void        EndOfCycle(AliQA::TASKINDEX)                           = 0 ;
+       virtual void        Exec(AliQA::TASKINDEX_t, TObject * data)                 = 0 ;
+       virtual void        EndOfCycle(AliQA::TASKINDEX_t)                           = 0 ;
        void                Finish() const ; 
     virtual TH1 *       GetDigitsData(const Int_t index)                       = 0 ; 
        virtual TH1 *       GetESDsData(const Int_t index)                         = 0 ; 
@@ -56,17 +56,18 @@ public:
        virtual TH1 *       GetSDigitsData(const Int_t index)                      = 0 ; 
        const char *        GetDetectorDirName() const { return fDetectorDirName.Data() ; }
        const Int_t         Increment() { return ++fCycleCounter ; } 
-       virtual TObjArray * Init(AliQA::TASKINDEX, Int_t run, Int_t cycles = -1)                   = 0 ;
-       virtual void        Init(AliQA::TASKINDEX, TObjArray * list, Int_t run, Int_t cycles = -1) = 0 ;
+       virtual TObjArray * Init(AliQA::TASKINDEX_t, Int_t run, Int_t cycles = -1)                   = 0 ;
+       virtual void        Init(AliQA::TASKINDEX_t, TObjArray * list, Int_t run, Int_t cycles = -1) = 0 ;
        const Bool_t        IsCycleDone() const { return fCycleCounter > fCycle ? kTRUE : kFALSE ; }
        void                Reset(const Bool_t sameCycle = kTRUE) ;     
     void                SetCycle(Int_t nevts) { fCycle = nevts ; } 
-       virtual void        StartOfCycle(AliQA::TASKINDEX, const Bool_t sameCycle = kFALSE) = 0 ;
+       virtual void        StartOfCycle(AliQA::TASKINDEX_t, const Bool_t sameCycle = kFALSE) = 0 ;
 
 protected: 
 
        Int_t          Add2List(TH1 * hist, const Int_t index, TObjArray * list) ;
-       virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * ) = 0 ; 
+       virtual void   DefaultEndOfDetectorCycle(AliQA::TASKINDEX_t task ) ; 
+       virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * obj ) = 0 ; 
        TObject *      GetData(TObjArray * list, const Int_t index) ;
        virtual void   InitDigits()        = 0 ; 
        virtual void   InitESDs()          = 0 ; 
index 64673a01c889e52f51c41dd1156bac24b955dfe1..26b5e9959ae62f785e20e115c69d45909774b5ef 100644 (file)
@@ -35,21 +35,21 @@ public:
        virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index)  { return Add2List(hist, index, fRecPointsQAList) ; }
        virtual Int_t Add2RawsList(TH1 * hist, const Int_t index)  { return Add2List(hist, index, fRawsQAList) ; }
        virtual Int_t Add2SDigitsList(TH1 * /*hist*/, const Int_t /*index*/)   { return -1 ; } 
-       virtual void        Exec(AliQA::TASKINDEX task, TObject * data) ;
-       virtual void        EndOfCycle(AliQA::TASKINDEX task) ;
+       virtual void        Exec(AliQA::TASKINDEX_t task, TObject * data) ;
+       virtual void        EndOfCycle(AliQA::TASKINDEX_t task) ;
        virtual TH1 *       GetDigitsData(const Int_t /*index*/)    { return NULL ; } 
        virtual TH1 *       GetESDsData(const Int_t index)      { return dynamic_cast<TH1 *>(GetData(fESDsQAList, index)) ; }
        virtual TH1 *       GetHitsData(const Int_t /*index*/)      { return NULL ; }
        virtual TH1 *       GetRecPointsData(const Int_t index) { return dynamic_cast<TH1 *>(GetData(fRecPointsQAList, index)) ; }
        virtual TH1 *       GetRawsData(const Int_t index)     { return dynamic_cast<TH1 *>(GetData(fRawsQAList, index)) ; }
        virtual TH1 *       GetSDigitsData(const Int_t /*index*/)   { return NULL ; }  
-       virtual TObjArray * Init(AliQA::TASKINDEX task, Int_t run, Int_t cycles = -1) ;
-       virtual void        Init(AliQA::TASKINDEX task, TObjArray * list, Int_t run, Int_t cycles = -1) ;
-       virtual void        StartOfCycle(AliQA::TASKINDEX task, const Bool_t sameCycle = kFALSE) ;
+       virtual TObjArray * Init(AliQA::TASKINDEX_t task, Int_t run, Int_t cycles = -1) ;
+       virtual void        Init(AliQA::TASKINDEX_t task, TObjArray * list, Int_t run, Int_t cycles = -1) ;
+       virtual void        StartOfCycle(AliQA::TASKINDEX_t task, const Bool_t sameCycle = kFALSE) ;
 
 protected: 
 
-       virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * ) {AliInfo("To be implemented by detectors");} 
+       virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray * ) {AliInfo("To be implemented by detectors");} 
        virtual void   InitDigits()                        {AliFatal("Call not valid") ; }
        virtual void   InitESDs()                          {AliInfo("To be implemented by detectors");}
        virtual void   InitHits()                          {AliFatal("Call not valid") ; }
index 302f7ff920e8e2bef5a446724132202ea995bef7..b601caeb742c8381d9eec2d87cdcc271c52f34b6 100644 (file)
@@ -68,7 +68,7 @@ AliQADataMakerSim& AliQADataMakerSim::operator = (const AliQADataMakerSim& qadm
 }
 
 //____________________________________________________________________________
-void AliQADataMakerSim::EndOfCycle(AliQA::TASKINDEX task) 
+void AliQADataMakerSim::EndOfCycle(AliQA::TASKINDEX_t task) 
 { 
   // Finishes a cycle of QA data acquistion
        TObjArray * list = 0x0 ; 
@@ -89,7 +89,7 @@ void AliQADataMakerSim::EndOfCycle(AliQA::TASKINDEX task)
 }
  
 //____________________________________________________________________________
-void AliQADataMakerSim::Exec(AliQA::TASKINDEX task, TObject * data) 
+void AliQADataMakerSim::Exec(AliQA::TASKINDEX_t task, TObject * data) 
 { 
   // creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs)
     
@@ -136,7 +136,7 @@ void AliQADataMakerSim::Exec(AliQA::TASKINDEX task, TObject * data)
 }
 
 //____________________________________________________________________________ 
-TObjArray *  AliQADataMakerSim::Init(AliQA::TASKINDEX task, Int_t run, Int_t cycles)
+TObjArray *  AliQADataMakerSim::Init(AliQA::TASKINDEX_t task, Int_t run, Int_t cycles)
 {
   // general intialisation
        
@@ -162,7 +162,7 @@ TObjArray *  AliQADataMakerSim::Init(AliQA::TASKINDEX task, Int_t run, Int_t cyc
 }
 
 //____________________________________________________________________________ 
-void AliQADataMakerSim::Init(AliQA::TASKINDEX task, TObjArray * list, Int_t run, Int_t cycles)
+void AliQADataMakerSim::Init(AliQA::TASKINDEX_t task, TObjArray * list, Int_t run, Int_t cycles)
 {
   // Intialisation by passing the list of QA data booked elsewhere
   
@@ -180,7 +180,7 @@ void AliQADataMakerSim::Init(AliQA::TASKINDEX task, TObjArray * list, Int_t run,
 }
 
 //____________________________________________________________________________
-void AliQADataMakerSim::StartOfCycle(AliQA::TASKINDEX task, const Bool_t sameCycle) 
+void AliQADataMakerSim::StartOfCycle(AliQA::TASKINDEX_t task, const Bool_t sameCycle) 
 { 
   // Finishes a cycle of QA data acquistion
        if ( !sameCycle || fCurrentCycle == -1) {
index c665f4cc36f29978bbe2e0e5c23733288d32b3d4..678b3325071badf7c199a115195a3ffbe0a6e087 100644 (file)
@@ -34,21 +34,21 @@ public:
        virtual Int_t Add2RecPointsList(TH1 * /*hist*/, const Int_t /*index*/) { return -1 ; } 
        virtual Int_t Add2RawsList(TH1 * /*hist*/, const Int_t /*index*/)      { return -1 ; }  
        virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index)   { return Add2List(hist, index, fSDigitsQAList) ; }
-       virtual void        Exec(AliQA::TASKINDEX task, TObject * data) ;
-       virtual void        EndOfCycle(AliQA::TASKINDEX task) ;
+       virtual void        Exec(AliQA::TASKINDEX_t task, TObject * data) ;
+       virtual void        EndOfCycle(AliQA::TASKINDEX_t task) ;
        virtual TH1 *       GetDigitsData(const Int_t index)    { return dynamic_cast<TH1 *>(GetData(fDigitsQAList, index)) ; }
        virtual TH1 *       GetESDsData(const Int_t /*index*/)      { return NULL ; }
        virtual TH1 *       GetHitsData(const Int_t index)      { return dynamic_cast<TH1 *>(GetData(fHitsQAList, index)) ; }
        virtual TH1 *       GetRecPointsData(const Int_t /*index*/) { return NULL ; }
        virtual TH1 *       GetRawsData(const Int_t /*index*/)      { return NULL ; } 
        virtual TH1 *       GetSDigitsData(const Int_t index)   { return dynamic_cast<TH1 *>(GetData(fSDigitsQAList, index)) ; }
-       virtual TObjArray * Init(AliQA::TASKINDEX task, Int_t run, Int_t cycles = -1) ;
-       virtual void        Init(AliQA::TASKINDEX task, TObjArray * list, Int_t run, Int_t cycles = -1) ;
-       virtual void        StartOfCycle(AliQA::TASKINDEX task, const Bool_t sameCycle = kFALSE) ;
+       virtual TObjArray * Init(AliQA::TASKINDEX_t task, Int_t run, Int_t cycles = -1) ;
+       virtual void        Init(AliQA::TASKINDEX_t task, TObjArray * list, Int_t run, Int_t cycles = -1) ;
+       virtual void        StartOfCycle(AliQA::TASKINDEX_t task, const Bool_t sameCycle = kFALSE) ;
 
 protected: 
        
-       virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * ) {AliInfo("To be implemented by detectors");} 
+       virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray * ) {AliInfo("To be implemented by detectors");} 
        virtual void   InitDigits()                     {AliInfo("To be implemented by detectors");}
        virtual void   InitESDs()                       {AliFatal("Call not valid") ; } 
        virtual void   InitHits()                       {AliInfo("To be implemented by detectors");}
index d2eeb5fb078cf2c375f89e104c5d991f10ec8485..9d663a97ccf610e954d1fa3a92da4a5ddc3ad977 100644 (file)
@@ -143,7 +143,7 @@ AliQADataMakerSteer::~AliQADataMakerSteer()
 }
 
 //_____________________________________________________________________________
-Bool_t AliQADataMakerSteer::DoIt(const AliQA::TASKINDEX taskIndex, const char * mode)
+Bool_t AliQADataMakerSteer::DoIt(const AliQA::TASKINDEX_t taskIndex, const char * mode)
 {
        // Runs all the QA data Maker for every detector
 
@@ -247,7 +247,7 @@ Bool_t AliQADataMakerSteer::DoIt(const AliQA::TASKINDEX taskIndex, const char *
 }
 
 //_____________________________________________________________________________
-Bool_t AliQADataMakerSteer::Finish(const AliQA::TASKINDEX taskIndex, const char * mode) 
+Bool_t AliQADataMakerSteer::Finish(const AliQA::TASKINDEX_t taskIndex, const char * mode) 
 {
        // write output to file for all detectors
        for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
@@ -262,7 +262,7 @@ Bool_t AliQADataMakerSteer::Finish(const AliQA::TASKINDEX taskIndex, const char
 }
 
 //_____________________________________________________________________________
-TObjArray * AliQADataMakerSteer::GetFromOCDB(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task, const char * year) const 
+TObjArray * AliQADataMakerSteer::GetFromOCDB(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, const char * year) const 
 {
        // Retrieve the list of QA data for a given detector and a given task 
        TObjArray * rv = NULL ;
@@ -277,10 +277,10 @@ TObjArray * AliQADataMakerSteer::GetFromOCDB(AliQA::DETECTORINDEX det, AliQA::TA
                tmp.Append(year) ; 
                tmp.Append("/") ; 
                man->SetDefaultStorage(tmp.Data()) ;            
-               man->SetSpecificStorage(Form("%s/*", AliQA::GetQAOCDBDirName()), AliQA::GetQARefStorage()) ;
+               man->SetSpecificStorage(Form("%s/*", AliQA::GetQAName()), AliQA::GetQARefStorage()) ;
        }
        char detOCDBDir[10] ; 
-       sprintf(detOCDBDir, "%s/%s/%s", AliQA::GetQAOCDBDirName(), AliQA::GetDetName((Int_t)det), AliQA::GetRefOCDBDirName()) ; 
+       sprintf(detOCDBDir, "%s/%s/%s", AliQA::GetQAName(), AliQA::GetDetName((Int_t)det), AliQA::GetRefOCDBDirName()) ; 
        AliInfo(Form("Retrieving reference data from %s/%s for %s", AliQA::GetQARefStorage(), detOCDBDir, AliQA::GetTaskName(task).Data())) ; 
        AliCDBEntry* entry = man->Get(detOCDBDir, 0) ; //FIXME 0 --> Run Number
        TList * listDetQAD = dynamic_cast<TList *>(entry->GetObject()) ;
@@ -369,7 +369,7 @@ AliQADataMaker * AliQADataMakerSteer::GetQADataMaker(const Int_t iDet, const cha
 }
 
 //_____________________________________________________________________________
-Bool_t AliQADataMakerSteer::Init(const AliQA::TASKINDEX taskIndex, const char * mode, const  char * input )
+Bool_t AliQADataMakerSteer::Init(const AliQA::TASKINDEX_t taskIndex, const char * mode, const  char * input )
 {
        // Initialize the event source and QA data makers
        
@@ -507,7 +507,6 @@ Bool_t AliQADataMakerSteer::IsSelected(const char * det)
        
        // search for the given detector
        Bool_t rv = kFALSE;
-       //AliInfo(Form("SSSSSSSSSSSSS fd = %s det = %s ", fDetectors.Data(), det)) ; 
        if ((fDetectors.CompareTo(detName) == 0) ||
                fDetectors.BeginsWith(detName+" ") ||
                fDetectors.EndsWith(" "+detName) ||
@@ -657,7 +656,7 @@ TString AliQADataMakerSteer::Run(const char * detectors, const char * fileName)
 }
 
 //_____________________________________________________________________________
-TString AliQADataMakerSteer::Run(const char * detectors, const AliQA::TASKINDEX taskIndex, const  char * fileName )
+TString AliQADataMakerSteer::Run(const char * detectors, const AliQA::TASKINDEX_t taskIndex, const  char * fileName )
 {
        // Runs all the QA data Maker for every detector
 
index d606b68a219b9b52a585f3584adfbba959901865..234c785843f3cddecf5d7e7966afedad2b80a2e4 100644 (file)
@@ -37,27 +37,27 @@ public:
        AliQADataMakerSteer & operator = (const AliQADataMakerSteer & qas) ; 
        virtual ~AliQADataMakerSteer() ; 
        UInt_t   GetCurrentEvent() const { return fCurrentEvent ; }
-    TObjArray * GetFromOCDB(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task, const char * year) const ; 
+    TObjArray * GetFromOCDB(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, const char * year) const ; 
        Bool_t  Merge(const Int_t runNumber = -1) const ;  
     void    Reset(const Bool_t sameCycle = kFALSE) ;  
-       TString Run(const char * detectors, const AliQA::TASKINDEX taskIndex, const char * fileName = NULL) ; 
+       TString Run(const char * detectors, const AliQA::TASKINDEX_t taskIndex, const char * fileName = NULL) ; 
        TString Run(const char * detectors, AliRawReader * rawReader) ; 
        TString Run(const char * detectors, const char * filename) ;
     Bool_t  Save2OCDB(const Int_t runNumber, const char * year = "08", const Int_t cycleNumber=0, const char * detectors = "ALL") const ; 
-       void    SetCycleLength(const AliQA::DETECTORINDEX det, const Int_t cycle) { fQACycles[det] = cycle ; }
+       void    SetCycleLength(const AliQA::DETECTORINDEX_t det, const Int_t cycle) { fQACycles[det] = cycle ; }
        void    SetMaxEvents(UInt_t max) { fMaxEvents = max ; }      
        void    SetNewCycle() { fCycleSame = kTRUE ; }
     void    SetRunLoader(AliRunLoader * rl) { fRunLoader = rl ; }
 
 private: 
-       Bool_t                   DoIt(const AliQA::TASKINDEX taskIndex, const char * mode) ;
+       Bool_t                   DoIt(const AliQA::TASKINDEX_t taskIndex, const char * mode) ;
        AliLoader      * GetLoader(Int_t iDet) ; 
        const Int_t      GetQACycles(const Int_t iDet) { return fQACycles[iDet] ; }
        AliQADataMaker * GetQADataMaker(const Int_t iDet, const char * mode) ; 
-       Bool_t                   Init(const AliQA::TASKINDEX taskIndex, const char * mode, const  char * fileName = NULL) ;
+       Bool_t                   Init(const AliQA::TASKINDEX_t taskIndex, const char * mode, const  char * fileName = NULL) ;
        Bool_t           InitRunLoader() ; 
        Bool_t           IsSelected(const char * detName)  ;
-       Bool_t           Finish(const AliQA::TASKINDEX taskIndex, const char * mode) ;
+       Bool_t           Finish(const AliQA::TASKINDEX_t taskIndex, const char * mode) ;
        Bool_t           SaveIt2OCDB(const Int_t runNumber, TFile * inputFile, const char * year) const ;  
 
  
index 528558f7fb9db1d708b1053e8c957aacccfef685..d12c2bbf609d1988d80b8b3a6f76b5731ad83758 100644 (file)
@@ -3164,8 +3164,8 @@ void AliReconstruction::CheckQA()
         
        for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
                TString detName(AliQA::GetDetName(iDet)) ;
-               AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX(iDet)) ; 
-               if ( qa->IsSet(AliQA::DETECTORINDEX(iDet), AliQA::kSIM, AliQA::kFATAL)) {
+               AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ; 
+               if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, AliQA::kFATAL)) {
                                AliInfo(Form("QA status for %s in Hits and/or SDIGITS  and/or Digits was Fatal; No reconstruction performed", detName.Data())) ;
                } else {
                        if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) ||