TList replaced by TObjArray as QA data container. Introducing OCDB for the reference...

diff --git a/HMPID/AliHMPIDQADataMaker.cxx b/HMPID/AliHMPIDQADataMaker.cxx
index 074a783..8f8bbca 100644 (file)
--- a/HMPID/AliHMPIDQADataMaker.cxx
+++ b/HMPID/AliHMPIDQADataMaker.cxx
@@ -111,7 +111,8 @@ void AliHMPIDQADataMaker::InitHits()
 {
   // create Hits histograms in Hits subdir
      fhHitQdc=new TH1F("HitQdc","HMPID Hit Qdc all chamber;QDC",500,0,4000);
-     for(Int_t iCh=0;iCh<7;iCh++) fhHitMap[iCh]=new TH2F(Form("HMPID HitMap%i",iCh),Form("Ch%i;x_{Hit};y_{Hit}",iCh),162,-1,161,146,-1,145);   
+     for(Int_t iCh=0;iCh<7;iCh++) 
+                fhHitMap[iCh]=new TH2F(Form("HMPID HitMap%i",iCh),Form("Ch%i;x_{Hit};y_{Hit}",iCh),162,-1,161,146,-1,145);   
 }
 
 //____________________________________________________________________________ 

diff --git a/ITS/AliITSQADataMaker.cxx b/ITS/AliITSQADataMaker.cxx
index e0433e7..e3e6fbd 100644 (file)
--- a/ITS/AliITSQADataMaker.cxx
+++ b/ITS/AliITSQADataMaker.cxx
@@ -90,7 +90,7 @@ void AliITSQADataMaker::StartOfDetectorCycle() const
 }
 
 //____________________________________________________________________________ 
-void AliITSQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TList *list)
+void AliITSQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray *list)
 {
   // launch the QA checking
   AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); 

diff --git a/ITS/AliITSQADataMaker.h b/ITS/AliITSQADataMaker.h
index 91cbb2b..7c48e8a 100644 (file)
--- a/ITS/AliITSQADataMaker.h
+++ b/ITS/AliITSQADataMaker.h
@@ -18,7 +18,7 @@
 
 
 #include "AliQADataMaker.h"
-class TList;
+class TObjArray;
 class TH1F;
 class TH2D;
 class AliRawReader;
@@ -32,7 +32,7 @@ public:
   AliITSQADataMaker(const AliITSQADataMaker& qadm);
   AliITSQADataMaker& operator = (const AliITSQADataMaker& qac);
   virtual void StartOfDetectorCycle() const;
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX task, TList * list);
+  virtual void EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list);
   virtual void EndOfDetectorCycle(const char * fgDataName);
   virtual void InitRaws();
   virtual void InitRecPoints();

diff --git a/MUON/AliMUONQADataMaker.cxx b/MUON/AliMUONQADataMaker.cxx
index 45d60c2..0982df6 100644 (file)
--- a/MUON/AliMUONQADataMaker.cxx
+++ b/MUON/AliMUONQADataMaker.cxx
@@ -82,7 +82,7 @@ AliMUONQADataMaker::~AliMUONQADataMaker()
 }
 
 //____________________________________________________________________________ 
-void AliMUONQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TList* list)
+void AliMUONQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray* list)
 {
     ///Detector specific actions at end of cycle
     // do the QA checking

diff --git a/MUON/AliMUONQADataMaker.h b/MUON/AliMUONQADataMaker.h
index 3c87922..5fdc238 100644 (file)
--- a/MUON/AliMUONQADataMaker.h
+++ b/MUON/AliMUONQADataMaker.h
@@ -13,7 +13,7 @@
 // to avoid circular dependencie
 
 // --- ROOT system ---
-class TList; 
+class TObjArray; 
 
 // --- AliRoot header files ---
 class AliMUONVClusterStore;
@@ -58,7 +58,7 @@ private:
   virtual void   MakeRaws(AliRawReader* rawReader); 
   virtual void   MakeRecPoints(TTree* recpo); 
   virtual void   MakeESDs(AliESDEvent* esd) ;
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TList* list);
+  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray* list);
 
   AliMUONVClusterStore* fClusterStore; //!< pointer to cluster store
 

diff --git a/PHOS/AliPHOSQADataMaker.cxx b/PHOS/AliPHOSQADataMaker.cxx
index ea756af..e09d466 100644 (file)
--- a/PHOS/AliPHOSQADataMaker.cxx
+++ b/PHOS/AliPHOSQADataMaker.cxx
@@ -75,7 +75,7 @@ AliPHOSQADataMaker& AliPHOSQADataMaker::operator = (const AliPHOSQADataMaker& qa
 }
  
 //____________________________________________________________________________ 
-void AliPHOSQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TList * list)
+void AliPHOSQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking

diff --git a/PHOS/AliPHOSQADataMaker.h b/PHOS/AliPHOSQADataMaker.h
index 1e9ed37..664e22a 100644 (file)
--- a/PHOS/AliPHOSQADataMaker.h
+++ b/PHOS/AliPHOSQADataMaker.h
@@ -16,7 +16,7 @@
 // --- ROOT system ---
 class TH1F ; 
 class TH1I ; 
-class TList ; 
+class TObjArray ; 
 
 // --- Standard library ---
 
@@ -32,7 +32,7 @@ public:
   virtual ~AliPHOSQADataMaker() {;} // dtor
   
 private:
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TList * list) ;
+  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * list) ;
   virtual void   InitHits() ; 
   virtual void   InitESDs() ; 
   virtual void   InitDigits() ; 

diff --git a/STEER/AliQA.cxx b/STEER/AliQA.cxx
index 1197b57..9ed7f5f 100644 (file)
--- a/STEER/AliQA.cxx
+++ b/STEER/AliQA.cxx
@@ -48,19 +48,23 @@
 
 
 ClassImp(AliQA)
-  AliQA    * AliQA::fgQA                = 0x0 ;
-  TFile    * AliQA::fgQADataFile        = 0x0 ;   
-  TString    AliQA::fgQADataFileName    = "QA" ;  // will transform into Det.QA.run.cycle.root  
-  TFile    * AliQA::fgQARefFile         = 0x0 ;   
-  TString    AliQA::fgQARefDirName             = "local://Ref/" ; 
-  TString    AliQA::fgQARefFileName     = "QA.root" ;
-  TFile    * AliQA::fgQAResultFile      = 0x0 ;  
-  TString    AliQA::fgQAResultDirName   = "local://RUN/" ;  
-  TString    AliQA::fgQAResultFileName  = "QA.root" ; 
-  TString    AliQA::fgDetNames[]  = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD",
-                                       "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"} ;   
-  TString   AliQA::fgTaskNames[]  = {"Raws", "Hits", "SDigits", "Digits", "RecPoints", "TrackSegments", "RecParticles", "ESDs"} ;   
-
+AliQA    * AliQA::fgQA                 = 0x0 ;
+TFile    * AliQA::fgQADataFile         = 0x0 ;   
+TString    AliQA::fgQADataFileName     = "QA" ;  // will transform into Det.QA.run.cycle.root  
+TFile    * AliQA::fgQARefFile          = 0x0 ;   
+TString    AliQA::fgQARefDirName          = "" ; 
+TString    AliQA::fgQARefFileName      = "QA.root" ;
+TFile    * AliQA::fgQAResultFile       = 0x0 ;  
+TString    AliQA::fgQAResultDirName    = "" ;  
+TString    AliQA::fgQAResultFileName   = "QA.root" ; 
+TString    AliQA::fgDetNames[]         = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD",
+                                                                                "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"} ;   
+TString       AliQA::fgTaskNames[]     = {"Raws", "Hits", "SDigits", "Digits", "RecPoints", "TrackSegments", "RecParticles", "ESDs"} ;   
+const TString AliQA::fkgLabLocalFile          = "file://"  ; 
+const TString AliQA::fkgLabLocalOCDB          = "local://" ;  
+const TString AliQA::fkgLabAliEnOCDB          = "alien://" ;  
+const TString AliQA::fkgRefFileName    = "QA.root" ; 
+const TString AliQA::fkgRefOCDBDirName = "QA/Ref"  ; 
 //____________________________________________________________________________
 AliQA::AliQA() : 
   TNamed("", ""), 
@@ -68,6 +72,7 @@ AliQA::AliQA() :
   fQA(new ULong_t[fNdet]), 
   fDet(kNULLDET),
   fTask(kNULLTASK)
+       
 {
   // default constructor
   // beware singleton: not to be used
@@ -103,7 +108,7 @@ AliQA::AliQA(const DETECTORINDEX det) :
   fNdet(kNDET),  
   fQA(new ULong_t[fNdet]), 
   fDet(det),
-  fTask(kNULLTASK)
+  fTask(kNULLTASK) 
 {
   // constructor to be used
   if (! CheckRange(det) ) {
@@ -301,22 +306,6 @@ TFile * AliQA::GetQADataFile(const char * fileName)
   return fgQADataFile ; 
 }
 
-//_______________________________________________________________
-TFile * AliQA::GetQARefFile() 
-{
-  // opens the file whwre Quality Assurance Reference Data are stored
-
-       if (!fgQARefFile) {
-               TString fileName(fgQARefDirName + fgQARefFileName) ; 
-
-               if ( fileName.Contains("local://")) 
-                       fileName.ReplaceAll("local://", "") ;
-
-               fgQARefFile = TFile::Open(fileName.Data(), "READ") ;
-       }
-       return fgQARefFile ; 
-}
-
 //_______________________________________________________________
 TFile * AliQA::GetQAResultFile() 
 {
@@ -324,8 +313,8 @@ TFile * AliQA::GetQAResultFile()
    
        if (!fgQAResultFile) { 
                TString dirName(fgQAResultDirName) ; 
-               if ( dirName.Contains("local://")) 
-                       dirName.ReplaceAll("local://", "") ;
+               if ( dirName.Contains(fkgLabLocalFile)) 
+                       dirName.ReplaceAll(fkgLabLocalFile, "") ;
                TString fileName(dirName + fgQAResultFileName) ; 
                TString opt("") ; 
                if ( !gSystem->AccessPathName(fileName) )
@@ -455,15 +444,22 @@ void AliQA::Set(QABIT bit)
 }
 
 //_____________________________________________________________________________
-void AliQA::SetQARefDir(const char * name)
+void AliQA::SetQARefStorage(const char * name)
 {
   // Set the root directory where the QA reference data are stored
 
-  fgQARefDirName.Prepend(name) ; 
-  printf("AliQA::SetQARefDir: QA references are in  %s\n", fgQARefDirName.Data()) ;
-  if ( fgQARefDirName.Contains("local://")) 
-    fgQARefDirName.ReplaceAll("local:/", "") ;
-  fgQARefFileName.Prepend(fgQARefDirName) ;
+  fgQARefDirName = name ; 
+  if ( fgQARefDirName.Contains(fkgLabLocalFile) )
+        fgQARefFileName =  fkgRefFileName ; 
+  else if (    fgQARefDirName.Contains(fkgLabLocalOCDB) )
+         fgQARefFileName =  fkgRefOCDBDirName ; 
+  else {
+         printf("ERROR: %s is an invalid storage definition\n", name) ; 
+         fgQARefDirName  = "" ; 
+         fgQARefFileName = "" ; 
+  }    
+       TString tmp(fgQARefDirName + fgQARefFileName) ;
+       printf("AliQA::SetQARefDir: QA references are in  %s\n", tmp.Data() ) ;
 }
 
 //_____________________________________________________________________________
@@ -473,8 +469,8 @@ void AliQA::SetQAResultDirName(const char * name)
 
   fgQAResultDirName.Prepend(name) ; 
   printf("AliQA::SetQAResultDirName: QA results are in  %s\n", fgQAResultDirName.Data()) ;
-  if ( fgQAResultDirName.Contains("local://")) 
-    fgQAResultDirName.ReplaceAll("local:/", "") ;
+  if ( fgQAResultDirName.Contains(fkgLabLocalFile)) 
+    fgQAResultDirName.ReplaceAll(fkgLabLocalFile, "") ;
   fgQAResultFileName.Prepend(fgQAResultDirName) ;
 }
 

diff --git a/STEER/AliQA.h b/STEER/AliQA.h
index c4f3856..adc0026 100644 (file)
--- a/STEER/AliQA.h
+++ b/STEER/AliQA.h
@@ -17,84 +17,89 @@ class TFile ;
 class AliQA : public TNamed {
 public:
 
-  enum DETECTORINDEX {
+       enum DETECTORINDEX {
     kNULLDET=-1, kITS, kTPC, kTRD, kTOF, kPHOS, kHMPID, kEMCAL, kMUON, kFMD,
-    kZDC, kPMD, kT0, kVZERO, kACORDE, kHLT, kNDET
-  };
-  enum ALITASK {
-    kNULLTASK=-1, kRAW, kSIM, kREC, kESD, kANA, kNTASK
-  };
-  enum QABIT {
-    kNULLBit=-1, kINFO, kWARNING, kERROR, kFATAL, kNBIT
-  };
+    kZDC, kPMD, kT0, kVZERO, kACORDE, kHLT, kNDET };
+       enum ALITASK {
+    kNULLTASK=-1, kRAW, kSIM, kREC, kESD, kANA, kNTASK };
+       enum QABIT {
+    kNULLBit=-1, kINFO, kWARNING, kERROR, kFATAL, kNBIT };
   
-  enum TASKINDEX {
-    kRAWS, kHITS, kSDIGITS, kDIGITS, kRECPOINTS, kTRACKSEGMENTS, kRECPARTICLES, kESDS
-  };
+       enum TASKINDEX {
+    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 AliQA& qa) ;   
-  AliQA& operator = (const AliQA& qa) ;
-  virtual ~AliQA();
+       // Creators - destructors
+       AliQA(); // beware singleton, not to be used
+       AliQA(const ALITASK tsk) ;
+       AliQA(const DETECTORINDEX 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) ;
-  const Bool_t           AddQAData2CDB(const char * defSto) const ;
-  const Bool_t           CheckFatal() const ;
-  static void            Close() ; 
-  static const char *    GetAliTaskName(ALITASK tsk) ;
-  static const TString   GetDetName(DETECTORINDEX det) { return fgDetNames[det] ; }
-  static const TString   GetTaskName(TASKINDEX 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 TFile *         GetQAResultFile() ; 
-  static TFile *         GetQARefFile() ; 
-  static const char  *   GetQAResultFileName() { return (fgQAResultDirName + fgQAResultFileName).Data() ; }
-  static const char  *   GetQARefFileName() { return (fgQARefDirName + fgQARefFileName).Data() ; }
-  const Bool_t           IsSet(DETECTORINDEX det, ALITASK tsk, QABIT bit) const ;
-  void                   Set(QABIT bit) ;
-  static void                   SetQAResultDirName(const char * name) ; 
-  static void            SetQARefDir(const char * name) ; 
-  void                   Show() const { ShowStatus(fDet) ; }
-  void                   ShowAll() const ;
+       static  AliQA *   Instance() ;
+       static  AliQA *   Instance(const DETECTORINDEX det) ;
+       static  AliQA *   Instance(const ALITASK tsk) ;
+       const Bool_t           AddQAData2CDB(const char * defSto) const ;
+       const Bool_t           CheckFatal() const ;
+       static void            Close() ; 
+       static const char *    GetAliTaskName(ALITASK 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 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 TFile *         GetQAResultFile() ; 
+       static const char  *   GetQAResultFileName() { return (fgQAResultDirName + fgQAResultFileName).Data() ; }
+       static const char  *   GetQARefFileName() { return fgQARefFileName ; }
+       static const char  *   GetQARefStorage() { return fgQARefDirName.Data() ; }
+       static const char  *   GetQARefOCDBDirName() { return fkgRefOCDBDirName .Data() ; }
+       const Bool_t           IsSet(DETECTORINDEX det, ALITASK tsk, QABIT bit) const ;
+       void                   Set(QABIT bit) ;
+       static void                        SetQAResultDirName(const char * name) ; 
+       static void            SetQARefStorage(const char * name) ; 
+       void                   Show() const { ShowStatus(fDet) ; }
+       void                   ShowAll() const ;
 
 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] ;}
-  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 ; AliInfo(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 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] ;}
+       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 ; AliInfo(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) ;
 
-  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)
-  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
-  static TFile *     fgQARefFile               ; //! the output file where the quality assurance maker store their results
-  static TString     fgQARefDirName            ; //! name of directory where to find the reference data file
-  static TString     fgQARefFileName   ; //! file name where to find the reference data
-  static TFile *     fgQAResultFile     ; //! File where to find the QA result
-  static TString     fgQAResultDirName  ; //! the location of the output file where the QA results are stored  
-  static TString     fgQAResultFileName ; //! the output file where the QA results are stored  
-  static TString     fgTaskNames[]             ; //! list of tasks names   
+       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)
+       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
+       static TFile *       fgQARefFile            ; //! the output file where the quality assurance maker store their results
+       static TString       fgQARefDirName         ; //! name of directory where to find the reference data file
+       static TString       fgQARefFileName    ; //! file name where to find the reference data
+       static TFile *       fgQAResultFile     ; //! File where to find the QA result
+       static TString       fgQAResultDirName  ; //! the location of the output file where the QA results are stored  
+       static TString       fgQAResultFileName ; //! the output file where the QA results are stored  
+       static TString       fgTaskNames[]          ; //! list of tasks names   
+       static const TString fkgLabLocalFile    ; //! label to identify a file as local 
+       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 fkgRefOCDBDirName  ; //! name of Reference directory name in OCDB          
 
  ClassDef(AliQA,1)  //ALICE Quality Assurance Object
 };

diff --git a/STEER/AliQAChecker.cxx b/STEER/AliQAChecker.cxx
index 17fc2d6..2bdbe49 100644 (file)
--- a/STEER/AliQAChecker.cxx
+++ b/STEER/AliQAChecker.cxx
@@ -21,6 +21,8 @@
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
 #include "AliLog.h"
 #include "AliModule.h" 
 #include "AliQA.h"
@@ -43,6 +45,7 @@ ClassImp(AliQAChecker)
 AliQAChecker::AliQAChecker(const char* name, const char* title) :
   TNamed(name, title),
   fDataFile(0x0), 
+  fRefFile(0x0), 
   fFoundDetectors(".")
 {
   // ctor: initialise checkers and open the data file   
@@ -54,6 +57,7 @@ AliQAChecker::AliQAChecker(const char* name, const char* title) :
 AliQAChecker::AliQAChecker(const AliQAChecker& qac) :
   TNamed(qac),
   fDataFile(qac.fDataFile), 
+  fRefFile(qac.fRefFile), 
   fFoundDetectors(qac.fFoundDetectors)
 {
   // copy constructor
@@ -121,24 +125,41 @@ AliQAChecker::~AliQAChecker()
 
 
 //_____________________________________________________________________________
-TDirectory * AliQAChecker::GetRefSubDir(const char * det, const char * task)     
+void AliQAChecker::GetRefSubDir(const char * det, const char * task, TDirectory *& dirFile, TList *& dirOCDB)     
 { 
   // Opens and returns the file with the reference data 
-  TFile * f = AliQA::GetQARefFile() ; //TFile::Open(fRefDirName, "READ") ;
-  TDirectory * rv = NULL ; 
-  if (!f) { 
-    AliError(Form("Cannot find reference file %s", (AliQA::GetQARefFileName()))) ; 
-    return rv ; 
-  }
-  rv = f->GetDirectory(det) ; 
-  if (!rv) {
-    AliWarning(Form("Directory %s not found in %d", det, (AliQA::GetQARefFileName()))) ; 
-  } else {
-    rv = rv->GetDirectory(task) ; 
-    if (!rv) 
-      AliWarning(Form("Directory %s/%s not found in %s", det, task, (AliQA::GetQARefFileName()))) ; 
-  }  
-  return rv ; 
+       
+       dirFile = NULL ; 
+       dirOCDB = NULL ; 
+       TString refStorage(AliQA::GetQARefStorage()) ; 
+       refStorage += AliQA::GetQARefFileName() ;
+       if (refStorage.Contains(AliQA::GetLabLocalFile())) {    
+               refStorage.ReplaceAll(AliQA::GetLabLocalFile(), "") ; 
+               if ( fRefFile ) 
+                       if ( fRefFile->IsOpen() ) 
+                               fRefFile->Close() ; 
+               fRefFile = TFile::Open(refStorage.Data()) ; 
+               if (!fRefFile) { 
+                       AliError(Form("Cannot find reference file %s", refStorage.Data())) ; 
+                       dirFile = NULL ; 
+               }
+               dirFile = fRefFile->GetDirectory(det) ; 
+               if (!dirFile) {
+                       AliWarning(Form("Directory %s not found in %d", det, refStorage.Data())) ; 
+               } else {
+                       dirFile = dirFile->GetDirectory(task) ; 
+                       if (!dirFile) 
+                               AliWarning(Form("Directory %s/%s not found in %s", det, task, refStorage.Data())) ; 
+               }  
+       } else if (refStorage.Contains(AliQA::GetLabLocalOCDB()) || refStorage.Contains(AliQA::GetLabAliEnOCDB())) {    
+               AliCDBManager* man = AliCDBManager::Instance() ; 
+               char detOCDBDir[20] ; 
+               sprintf(detOCDBDir, "%s/%s", AliQA::GetQARefFileName(), det) ; 
+               AliCDBEntry * entry = man->Get(detOCDBDir) ;
+               TList * listDetQAD = dynamic_cast<TList *>(entry->GetObject()) ;
+               if ( listDetQAD ) 
+                       dirOCDB = dynamic_cast<TList *>(listDetQAD->FindObject(task)) ; 
+       }
 }
 
 //_____________________________________________________________________________
@@ -211,13 +232,15 @@ Bool_t AliQAChecker::Run(const char * fileName)
                index = AliQA::kESD ; 
       qac->Init(AliQA::DETECTORINDEX(det)) ; 
 
-         TDirectory * refDir = GetRefSubDir(detNameQA.Data(), taskName.Data()) ;
-         if ( refDir ) { 
-               qac->SetRefandData(refDir, taskDir) ; 
-               qac->Run(index) ; 
+         TDirectory * refDir     = NULL ; 
+         TList * refOCDBDir      = NULL ;      
+         GetRefSubDir(detNameQA.Data(), taskName.Data(), refDir, refOCDBDir) ;
+         if ( refDir || refOCDBDir) {
+                 qac->SetRefandData(refDir, refOCDBDir, taskDir) ;
+                 qac->Run(index) ; 
          }
-    }
- }
+       }
+  }
   AliInfo("QA performed for following detectors:") ; 
   for ( Int_t det = 0; det < AliQA::kNDET; det++) {
     if (fFoundDetectors.Contains(AliQA::GetDetName(det))) {
@@ -233,7 +256,7 @@ Bool_t AliQAChecker::Run(const char * fileName)
 }
 
 //_____________________________________________________________________________
-Bool_t AliQAChecker::Run(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task, TList * list)
+Bool_t AliQAChecker::Run(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task, TObjArray * list)
 {
   // run the Quality Assurance Checker for detector det, for task task starting from data in list
 
@@ -260,11 +283,14 @@ Bool_t AliQAChecker::Run(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task, TList
                index = AliQA::kREC ; 
   else if ( task == AliQA::kESDS ) 
                index = AliQA::kESD ; 
-  TDirectory * refDir = GetRefSubDir(AliQA::GetDetName(det).Data(), AliQA::GetTaskName(task).Data()) ;
-  if ( refDir ) { 
-       qac->Init(det) ; 
-       qac->SetRefandData(refDir) ; 
-       qac->Run(index, list) ; 
+
+  TDirectory * refDir = NULL ; 
+  TList *refOCDBDir   = NULL ; 
+       GetRefSubDir(AliQA::GetDetName(det), AliQA::GetTaskName(task), refDir, refOCDBDir) ;
+  if ( refDir || refOCDBDir) {
+         qac->Init(det) ; 
+         qac->SetRefandData(refDir, refOCDBDir) ; 
+         qac->Run(index, list) ; 
   }
   return kTRUE ; 
   

diff --git a/STEER/AliQAChecker.h b/STEER/AliQAChecker.h
index a8ca771..3cf384e 100644 (file)
--- a/STEER/AliQAChecker.h
+++ b/STEER/AliQAChecker.h
@@ -18,6 +18,7 @@
 #include <TFile.h>  
 
 #include "AliQA.h"
+class AliCDBEntry ; 
 class AliQACheckerBase ; 
 
 class AliQAChecker: public TNamed {
@@ -30,19 +31,20 @@ public:
 
   static  AliQAChecker * Instance() ;
   AliQACheckerBase *     GetDetQAChecker(Int_t det) ; 
-  TDirectory *           GetRefSubDir(const char * det, const char * task) ;
+  void                   GetRefSubDir(const char * det, const char * task, TDirectory *& dirFile, TList *& dirOCDB) ;
 //  static TFile *         GetQAResultFile() ;
 //  static const char *    GetQAResultFileName() { return fgQAResultFileName.Data() ; }
 //  void                   SetQAResultDirName(const char * name) ; 
 //  void                   SetRefDirName(const char * name) ; 
 
   virtual Bool_t Run(const char * fileName = NULL) ;
-  virtual Bool_t Run(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task, TList * list);
+  virtual Bool_t Run(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task, TObjArray * list);
 
 private:
 
   static AliQAChecker *fgQAChecker ; // pointer to the instance of the singleton
   TFile * fDataFile ;                     //! Data file to check
+  TFile * fRefFile ;                      //! Reference Data file 
   TString fFoundDetectors ;               //! detectors for which the Quality assurance could be done
   AliQACheckerBase * fCheckers[AliQA::kNDET] ; //! list of detectors checkers
   ClassDef(AliQAChecker, 1)  // class for running generation, simulation and digitization

diff --git a/STEER/AliQACheckerBase.cxx b/STEER/AliQACheckerBase.cxx
index 77f1634..e61d526 100644 (file)
--- a/STEER/AliQACheckerBase.cxx
+++ b/STEER/AliQACheckerBase.cxx
@@ -47,16 +47,18 @@ ClassImp(AliQACheckerBase)
 AliQACheckerBase::AliQACheckerBase(const char * name, const char * title) : 
   TNamed(name, title), 
   fDataSubDir(0x0),
-  fRefSubDir(0x0) 
+  fRefSubDir(0x0), 
+  fRefOCDBSubDir(0x0)
 {
   // ctor
 }
 
 //____________________________________________________________________________ 
-AliQACheckerBase::AliQACheckerBase(const AliQACheckerBase& qadm) :
-  TNamed(qadm.GetName(), qadm.GetTitle()),
-  fDataSubDir(qadm.fDataSubDir), 
-  fRefSubDir(qadm.fRefSubDir)
+AliQACheckerBase::AliQACheckerBase(const AliQACheckerBase& qac) :
+  TNamed(qac.GetName(), qac.GetTitle()),
+  fDataSubDir(qac.fDataSubDir), 
+  fRefSubDir(qac.fRefSubDir), 
+  fRefOCDBSubDir(qac.fRefOCDBSubDir)
 {
   //copy ctor
     
@@ -76,6 +78,7 @@ const Double_t AliQACheckerBase::Check()
 {
   // Performs a basic checking
   // 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 ; 
@@ -83,32 +86,36 @@ const Double_t AliQACheckerBase::Check()
    if (!fDataSubDir)  
      test = 1. ; // nothing to check
    else 
-     if (!fRefSubDir)
+     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  = static_cast<TH1*>(fRefSubDir->Get(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())) ;
-       }
-
-     }
+                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 ;
    
@@ -116,7 +123,7 @@ const Double_t AliQACheckerBase::Check()
 }  
 
 //____________________________________________________________________________
-const Double_t AliQACheckerBase::Check(TList * list) 
+const Double_t AliQACheckerBase::Check(TObjArray * list) 
 {
   // Performs a basic checking
   // Compares all the histograms in the list
@@ -126,7 +133,7 @@ const Double_t AliQACheckerBase::Check(TList * list)
 
    if (list->GetEntries() == 0)  
      test = 1. ; // nothing to check
-   else 
+   else {
      if (!fRefSubDir)
        test = -1 ; // no reference data
      else {
@@ -135,24 +142,28 @@ const Double_t AliQACheckerBase::Check(TList * list)
        count = 0 ; 
        while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
                if ( hdata) { 
-            TH1 * href  = static_cast<TH1*>(fRefSubDir->Get(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 ; 
+                       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 ;
 }  
 
 //____________________________________________________________________________ 
@@ -186,7 +197,7 @@ void AliQACheckerBase::Init(const AliQA::DETECTORINDEX det)
 }
  
 //____________________________________________________________________________
-void AliQACheckerBase::Run(AliQA::ALITASK index, TList * list) 
+void AliQACheckerBase::Run(AliQA::ALITASK index, TObjArray * list) 
 { 
   AliInfo(Form("Processing %s", AliQA::GetAliTaskName(index))) ; 
 

diff --git a/STEER/AliQACheckerBase.h b/STEER/AliQACheckerBase.h
index cf3cf15..0ae34ff 100644 (file)
--- a/STEER/AliQACheckerBase.h
+++ b/STEER/AliQACheckerBase.h
@@ -18,7 +18,7 @@
 #include "AliQA.h"
 class TFile ; 
 class TH1 ; 
-class TList ; 
+class TObjArray ; 
 class TDirectory ; 
 
 // --- Standard library ---
@@ -34,18 +34,19 @@ public:
   virtual ~AliQACheckerBase() {;} // dtor
 
   void   Init(const AliQA::DETECTORINDEX det) ; 
-  void   Run(AliQA::ALITASK tsk, TList * list=0x0); 
-  void   SetRefandData(TDirectory * ref, TDirectory * data=NULL) { fRefSubDir = ref ;  fDataSubDir = data ; }
+  void   Run(AliQA::ALITASK tsk, TObjArray * list=0x0); 
+  void   SetRefandData(TDirectory * ref, TList * refOCDB, TDirectory * data=NULL) { fRefSubDir = ref ;  fRefOCDBSubDir = refOCDB, fDataSubDir = data ; }
 
 protected:
   virtual const Double_t Check() ;
-  virtual const Double_t Check(TList * list) ;
+  virtual const Double_t Check(TObjArray * list) ;
   const Double_t DiffC(const TH1 * href, const TH1 * hin) const ;   
   const Double_t DiffK(const TH1 * href, const TH1 * hin) const ;   
   void           Finish() const ; 
 
-  TDirectory * fDataSubDir ; //! directory for the current task directory in the current detector directory in the data file
-  TDirectory * fRefSubDir  ; //! directory for the current task directory in the current detector directory in the reference file
+  TDirectory  * fDataSubDir    ; //! directory for the current task directory in the current detector directory in the data file
+  TDirectory  * fRefSubDir     ; //! directory for the current task directory in the current detector directory in the reference file
+  TList       * fRefOCDBSubDir ; //! Entry in OCDB for the current detector 
 
   ClassDef(AliQACheckerBase,1)  // description 
 

diff --git a/STEER/AliQADataMaker.cxx b/STEER/AliQADataMaker.cxx
index e027a9d..2a32831 100644 (file)
--- a/STEER/AliQADataMaker.cxx
+++ b/STEER/AliQADataMaker.cxx
@@ -93,12 +93,12 @@ AliQADataMaker& AliQADataMaker::operator = (const AliQADataMaker& qadm )
 }
 
 //____________________________________________________________________________
-Int_t AliQADataMaker::Add2List(TH1 * hist, const Int_t index, TList * list) 
+Int_t AliQADataMaker::Add2List(TH1 * hist, const Int_t index, TObjArray * list) 
 { 
        // Set histograms memory resident and add to the list 
        hist->SetDirectory(0) ; 
        list->AddAt(hist, index) ; 
-       return list->LastIndex() ; 
+       return list->GetLast() ; 
 }
 
 //____________________________________________________________________________
@@ -106,7 +106,7 @@ void AliQADataMaker::EndOfCycle(AliQA::TASKINDEX task)
 { 
   // Finishes a cycle of QA data acquistion
   
- TList * list = 0x0 ; 
+ TObjArray * list = 0x0 ; 
   
  switch (task) { 
   
@@ -139,6 +139,9 @@ void AliQADataMaker::EndOfCycle(AliQA::TASKINDEX task)
    case AliQA::kESDS:
        list = fESDsQAList ; 
    break ;  
+
+   case AliQA::kNTASKINDEX:
+   break ;  
   }    
   
  EndOfDetectorCycle(task, list) ; 
@@ -231,7 +234,7 @@ void AliQADataMaker::Exec(AliQA::TASKINDEX task, TObject * data)
                case AliQA::kRECPARTICLES:
                        AliInfo("Processing RecParticles QA: not existing anymore") ; 
                        //       MakeRecParticles(recpar) ;
-               break ;  
+                       break ;  
                case AliQA::kESDS:
                {
                        AliDebug(1, "Processing ESDs QA") ; 
@@ -241,6 +244,8 @@ void AliQADataMaker::Exec(AliQA::TASKINDEX task, TObject * data)
                        else 
                                AliError("Wrong type of esd container") ; 
                        break ;
+                       case AliQA::kNTASKINDEX:
+                       break ;  
                }  
        }         
 }
@@ -253,7 +258,7 @@ void AliQADataMaker::Finish() const
 } 
 
 //____________________________________________________________________________ 
-TList *  AliQADataMaker::Init(AliQA::TASKINDEX task, Int_t run, Int_t cycles)
+TObjArray *  AliQADataMaker::Init(AliQA::TASKINDEX task, Int_t run, Int_t cycles)
 {
   // general intialisation
   
@@ -264,35 +269,35 @@ TList *  AliQADataMaker::Init(AliQA::TASKINDEX task, Int_t run, Int_t cycles)
   switch (task) {
   case AliQA::kRAWS: 
    {
-       fRawsQAList = new TList() ;      
+       fRawsQAList = new TObjArray(100) ;       
     InitRaws() ;
        return fRawsQAList ;
     break ; 
    }
   case AliQA::kHITS: 
    {
-       fHitsQAList = new TList() ;      
+       fHitsQAList = new TObjArray(100) ;       
     InitHits() ;
        return fHitsQAList ;
     break ; 
    }
   case AliQA::kSDIGITS: 
    {
-       fSDigitsQAList = new TList() ; 
+       fSDigitsQAList = new TObjArray(100) ; 
     InitSDigits() ;
        return fSDigitsQAList ;
     break ; 
    }
   case AliQA::kDIGITS: 
    {
-       fDigitsQAList = new TList(); 
+       fDigitsQAList = new TObjArray(100); 
        InitDigits() ;
        return fDigitsQAList ;
        break ; 
    }     
   case AliQA::kRECPOINTS: 
    {
-       fRecPointsQAList = new TList() ; 
+       fRecPointsQAList = new TObjArray(100) ; 
     InitRecPoints() ;
        return fRecPointsQAList ;
     break ; 
@@ -307,17 +312,19 @@ TList *  AliQADataMaker::Init(AliQA::TASKINDEX task, Int_t run, Int_t cycles)
     
   case AliQA::kESDS: 
    {
-       fESDsQAList = new TList() ; 
+       fESDsQAList = new TObjArray(100) ; 
        InitESDs() ;
        return fESDsQAList ;
     break ; 
    }
+  case AliQA::kNTASKINDEX: 
+  break ; 
   }  
   return 0x0 ; 
 }
 
 //____________________________________________________________________________ 
-void AliQADataMaker::Init(AliQA::TASKINDEX task, TList * list, Int_t run, Int_t cycles)
+void AliQADataMaker::Init(AliQA::TASKINDEX task, TObjArray * list, Int_t run, Int_t cycles)
 {
   // Intialisation by passing the list of QA data booked elsewhere
   
@@ -362,6 +369,8 @@ void AliQADataMaker::Init(AliQA::TASKINDEX task, TList * list, Int_t run, Int_t
        fESDsQAList = list ; 
     break ; 
    }
+  case AliQA::kNTASKINDEX: 
+  break ; 
   }  
 }
 
@@ -396,7 +405,7 @@ void AliQADataMaker::StartOfCycle(AliQA::TASKINDEX task, const Bool_t sameCycle)
    subDir = fDetectorDir->mkdir(AliQA::GetTaskName(task)) ;  
  subDir->cd() ; 
 
-  TList * list = 0x0 ; 
+  TObjArray * list = 0x0 ; 
   
   switch (task) { 
   case AliQA::kRAWS: 
@@ -428,7 +437,10 @@ void AliQADataMaker::StartOfCycle(AliQA::TASKINDEX task, const Bool_t sameCycle)
   case AliQA::kESDS: 
        list = fESDsQAList ;
     break ; 
-  }  
+
+  case AliQA::kNTASKINDEX: 
+       break ; 
+}  
 
  TIter next(list) ;
  TH1 * h ; 

diff --git a/STEER/AliQADataMaker.h b/STEER/AliQADataMaker.h
index 2c1f1d0..ad5f7bc 100644 (file)
--- a/STEER/AliQADataMaker.h
+++ b/STEER/AliQADataMaker.h
@@ -16,15 +16,15 @@
 
 // --- ROOT system ---
 #include <TH1.h>
-#include <TList.h>
+#include <TObjArray.h>
 #include <TNamed.h>  
-class TFile;  
+class TClonesArray;
 class TDirectory;
+class TFile;  
 class TObject; 
 class TTree; 
 class AliESDEvent;
 class AliRawReader;
-class TClonesArray;
 
 // --- Standard library ---
 
@@ -57,8 +57,8 @@ public:
   TH1 *               GetSDigitsData(const Int_t index)   { return dynamic_cast<TH1 *>(GetData(fSDigitsQAList, index)) ; }
   const char *        GetDetectorDirName() { return fDetectorDirName.Data() ; }
   const Int_t         Increment() { return ++fCycleCounter ; } 
-  TList *             Init(AliQA::TASKINDEX, Int_t run, Int_t cycles = -1) ;
-  void                Init(AliQA::TASKINDEX, TList * list, Int_t run, Int_t cycles = -1) ;
+  TObjArray *         Init(AliQA::TASKINDEX, Int_t run, Int_t cycles = -1) ;
+  void                Init(AliQA::TASKINDEX, TObjArray * list, Int_t run, Int_t cycles = -1) ;
   const Bool_t        IsCycleDone() const { return fCycleCounter > fCycle ? kTRUE : kFALSE ; }
   void                Reset() ;        
   void                SetCycle(Int_t nevts) { fCycle = nevts ; } 
@@ -66,9 +66,9 @@ public:
 
 protected: 
 
-  Int_t          Add2List(TH1 * hist, const Int_t index, TList * list) ;
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TList * ) {AliInfo("To be implemented by detectors");} 
-  TObject *      GetData(TList * list, const Int_t index)  { return list->At(index) ; } 
+  Int_t          Add2List(TH1 * hist, const Int_t index, TObjArray * list) ;
+  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * ) {AliInfo("To be implemented by detectors");} 
+  TObject *      GetData(TObjArray * list, const Int_t index)  { return list->At(index) ; } 
   virtual void   InitDigits()        {AliInfo("To be implemented by detectors");}
   virtual void   InitESDs()          {AliInfo("To be implemented by detectors");}
   virtual void   InitHits()          {AliInfo("To be implemented by detectors");}
@@ -94,12 +94,12 @@ protected:
   TFile *        fOutput ;          //! output root file
   TDirectory *   fDetectorDir ;     //! directory for the given detector in the file
   TString        fDetectorDirName ; //! detector directory name in the quality assurance data file
-  TList *        fDigitsQAList ;    //! list of the digits QA data objects
-  TList *        fESDsQAList ;      //! list of the ESDs QA data objects
-  TList *        fHitsQAList ;      //! list of the hits QA data objects
-  TList *        fRawsQAList ;      //! list of the raws QA data objects
-  TList *        fRecPointsQAList ; //! list of the recpoints QA data objects
-  TList *        fSDigitsQAList ;   //! list of the sdigits QA data objects
+  TObjArray *    fDigitsQAList ;    //! list of the digits QA data objects
+  TObjArray *    fESDsQAList ;      //! list of the ESDs QA data objects
+  TObjArray *    fHitsQAList ;      //! list of the hits QA data objects
+  TObjArray *    fRawsQAList ;      //! list of the raws QA data objects
+  TObjArray *    fRecPointsQAList ; //! list of the recpoints QA data objects
+  TObjArray *    fSDigitsQAList ;   //! list of the sdigits QA data objects
   Int_t          fCurrentCycle ;    //! current cycle number
   Int_t          fCycle ;           //! length (# events) of the QA data acquisition cycle  
   Int_t          fCycleCounter ;    //! cycle counter

diff --git a/STEER/AliQADataMakerSteer.cxx b/STEER/AliQADataMakerSteer.cxx
index 99729b6..6c0df97 100644 (file)
--- a/STEER/AliQADataMakerSteer.cxx
+++ b/STEER/AliQADataMakerSteer.cxx
@@ -15,6 +15,7 @@
 
 /* $Id$ */
 
+#include <TKey.h>
 #include <TFile.h>
 #include <TFileMerger.h>
 #include <TPluginManager.h>
@@ -22,6 +23,10 @@
 #include <TString.h>
 #include <TSystem.h>
 
+#include "AliCDBManager.h"
+#include "AliCDBEntry.h"
+#include "AliCDBId.h"
+#include "AliCDBMetaData.h"
 #include "AliESDEvent.h"
 #include "AliHeader.h"
 #include "AliLog.h"
@@ -205,6 +210,8 @@ Bool_t AliQADataMakerSteer::DoIt(const AliQA::TASKINDEX taskIndex)
                                                case AliQA::kESDS :
                                                qadm->Exec(taskIndex, fESD) ;
                                                break; 
+                                               case AliQA::kNTASKINDEX :
+                                               break; 
                                } //task switch
                                qadm->Increment() ; 
                        } //data maker exist
@@ -215,6 +222,39 @@ Bool_t AliQADataMakerSteer::DoIt(const AliQA::TASKINDEX taskIndex)
        return rv ; 
 }
 
+//_____________________________________________________________________________
+Bool_t AliQADataMakerSteer::Finish(const AliQA::TASKINDEX taskIndex) 
+{
+       // write output to file for all detectors
+       for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
+               if (IsSelected(AliQA::GetDetName(iDet))) {
+                       AliQADataMaker * qadm = GetQADataMaker(iDet) ;
+                       if (qadm) {
+                               qadm->EndOfCycle(taskIndex) ; 
+                       }
+               }
+       }
+       return kTRUE ; 
+}
+
+//_____________________________________________________________________________
+TList * AliQADataMakerSteer::GetFromOCDB(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task) const 
+{
+       // Retrieve the list of QA data for a given detector and a given task 
+       TList * rv = NULL ;
+       AliCDBManager* man = AliCDBManager::Instance() ; 
+       man->SetDefaultStorage("local://TestCDB")  ; 
+       char detOCDBDir[20] ; 
+       sprintf(detOCDBDir, "QA/Ref/%s", AliQA::GetDetName((Int_t)det)) ; 
+       AliInfo(Form("Retrieving reference data from local://TestCDB/%s %s", detOCDBDir, AliQA::GetTaskName(task).Data())) ; 
+       AliCDBEntry* entry = man->Get(detOCDBDir,0) ;
+       TList * listDetQAD = dynamic_cast<TList *>(entry->GetObject()) ;
+       if ( listDetQAD ) 
+               rv = dynamic_cast<TList *>(listDetQAD->FindObject(AliQA::GetTaskName(task))) ; 
+
+       return rv ; 
+}
+
 //_____________________________________________________________________________
 AliLoader * AliQADataMakerSteer::GetLoader(Int_t iDet)
 {
@@ -432,26 +472,15 @@ Bool_t AliQADataMakerSteer::InitRunLoader()
 }
 
 //_____________________________________________________________________________
-Bool_t AliQADataMakerSteer::Finish(const AliQA::TASKINDEX taskIndex) 
-{
-       // write output to file for all detectors
-       for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
-               if (IsSelected(AliQA::GetDetName(iDet))) {
-                       AliQADataMaker * qadm = GetQADataMaker(iDet) ;
-                       if (qadm) {
-                               qadm->EndOfCycle(taskIndex) ; 
-                       }
-               }
-       }
-       return kTRUE ; 
-}
-
-//_____________________________________________________________________________
-Bool_t AliQADataMakerSteer::Merge() 
+Bool_t AliQADataMakerSteer::Merge(const Int_t runNumber) const
 {
        // Merge all the cycles from all detectors in one single file per run
-       
-       gROOT->ProcessLine(".! ls *QA*.*.*.root > tempo.txt") ; 
+       char cmd[80] ;
+       if ( runNumber == -1 )
+               sprintf(cmd, ".! ls *%s*.*.*.root > tempo.txt", AliQA::GetQADataFileName()) ; 
+       else 
+               sprintf(cmd, ".! ls *%s*.%d.*.root > tempo.txt", AliQA::GetQADataFileName(), runNumber) ; 
+       gROOT->ProcessLine(cmd) ;
        ifstream in("tempo.txt") ; 
        const Int_t runMax = 10 ;  
        TString file[AliQA::kNDET*runMax] ;
@@ -459,17 +488,26 @@ Bool_t AliQADataMakerSteer::Merge()
        
        Int_t index = 0 ; 
        while ( 1 ) {
-               in >> file[index++] ; 
+               in >> file[index] ; 
                if ( !in.good() ) 
                        break ; 
+               index++ ;
+       }
+       
+       if ( index == 0 ) { 
+               AliError(Form("run number %d not found", runNumber)) ; 
+               return kFALSE ; 
        }
+       
        Int_t previousRun = -1 ;
        Int_t runIndex = 0 ;  
+       char stmp[10] ; 
+       sprintf(stmp, ".%s.", AliQA::GetQADataFileName()) ; 
        for (Int_t ifile = 0 ; ifile < index-1 ; ifile++) {
                TString tmp(file[ifile]) ; 
                tmp.ReplaceAll(".root", "") ; 
                TString det = tmp(0, tmp.Index(".")) ; 
-               tmp.Remove(0, tmp.Index(".QA.")+4) ; 
+               tmp.Remove(0, tmp.Index(stmp)+4) ; 
                TString ttmp = tmp(0, tmp.Index(".")) ; 
                Int_t newRun = ttmp.Atoi() ;
                if (newRun != previousRun) {
@@ -483,12 +521,12 @@ Bool_t AliQADataMakerSteer::Merge()
        }
        for (Int_t irun = 0 ; irun < runIndex ; irun++) {
                TFileMerger merger ; 
-               char outFileName[runMax] ; 
-               sprintf(outFileName, "Merged.QA.%d.root", runIndex-1) ; 
+               char outFileName[20] ; 
+               sprintf(outFileName, "Merged.%s.%d.root", AliQA::GetQADataFileName(), runIndex-1) ; 
                merger.OutputFile(outFileName) ; 
                for (Int_t ifile = 0 ; ifile < index-1 ; ifile++) {
                        char pattern[100] ; 
-                       sprintf(pattern, "QA.%d.", runIndex-1) ; 
+                       sprintf(pattern, "%s.%d.", AliQA::GetQADataFileName(), runIndex-1) ; 
                        TString tmp(file[ifile]) ; 
                        if (tmp.Contains(pattern))
                                merger.AddFile(tmp) ; 
@@ -569,3 +607,89 @@ Bool_t AliQADataMakerSteer::Run(const char * detectors, const AliQA::TASKINDEX t
        return rv ;   
 
 }
+
+//_____________________________________________________________________________
+Bool_t AliQADataMakerSteer::Save2OCDB(const Int_t runNumber, const Int_t cycleNumber, const char * detectors) const
+{
+       // take the locasl QA data merge into a single file and save in OCDB 
+       Bool_t rv = kTRUE ; 
+       TString tmp(AliQA::GetQARefStorage()) ; 
+       if ( tmp.IsNull() ) { 
+               AliError("No storage defined, use AliQA::SetQARefStorage") ; 
+               return kFALSE ; 
+       }
+       if ( !(tmp.Contains(AliQA::GetLabLocalOCDB()) || tmp.Contains(AliQA::GetLabAliEnOCDB())) ) {
+               AliError(Form("%s is a wrong storage, use %s or %s", AliQA::GetQARefStorage(), AliQA::GetLabLocalOCDB().Data(), AliQA::GetLabAliEnOCDB().Data())) ; 
+               return kFALSE ; 
+       }
+       TString sdet(detectors) ; 
+       sdet.ToUpper() ;
+       TFile * inputFile ; 
+       if ( sdet.Contains("ALL") ) {
+               rv = Merge(runNumber) ; 
+               if ( ! rv )
+                       return kFALSE ; 
+               char inputFileName[20] ; 
+               sprintf(inputFileName, "Merged.%s.%d.root", AliQA::GetQADataFileName(), runNumber) ; 
+               inputFile = TFile::Open(inputFileName) ; 
+               rv = SaveIt2OCDB(inputFile) ; 
+       } else {
+               for (Int_t index = 0; index < AliQA::kNDET; index++) {
+                       if (sdet.Contains(AliQA::GetDetName(index))) {
+                               char inputFileName[20] ; 
+                               sprintf(inputFileName, "%s.%s.%d.%d.root", AliQA::GetDetName(index), AliQA::GetQADataFileName(), runNumber, cycleNumber) ; 
+                               inputFile = TFile::Open(inputFileName) ;                        
+                               rv *= SaveIt2OCDB(inputFile) ; 
+                       }
+               }
+       }
+       return rv ; 
+}
+
+//_____________________________________________________________________________
+Bool_t AliQADataMakerSteer::SaveIt2OCDB(TFile * inputFile) const
+{
+       // reads the TH1 from file and adds it to appropriate list before saving to OCDB
+       Bool_t rv = kTRUE ;
+       AliInfo(Form("Saving TH1s in %s to %s", inputFile->GetName(), AliQA::GetQARefStorage())) ; 
+       AliCDBManager* man = AliCDBManager::Instance() ; 
+       man->SetDefaultStorage(AliQA::GetQARefStorage()) ; 
+
+       for ( Int_t detIndex = 0 ; detIndex < AliQA::kNDET ; detIndex++) {
+               TDirectory * detDir = inputFile->GetDirectory(AliQA::GetDetName(detIndex)) ; 
+               if ( detDir ) {
+                       AliInfo(Form("Entering %s", detDir->GetName())) ;
+                       char detOCDBDir[20] ; 
+                       sprintf(detOCDBDir, "QA/Ref/%s", AliQA::GetDetName(detIndex)) ; 
+                       AliCDBId idr(detOCDBDir,0,999999999)  ;
+                       TList * listDetQAD = new TList() ;
+                       char listName[20] ; 
+                       sprintf(listName, "%s QA data Reference", AliQA::GetDetName(detIndex)) ; 
+                       listDetQAD->SetName(listName) ; 
+                       TList * taskList = detDir->GetListOfKeys() ; 
+                       TIter nextTask(taskList) ; 
+                       TKey * taskKey ; 
+                       while ( (taskKey = dynamic_cast<TKey*>(nextTask())) ) {
+                               TDirectory * taskDir = detDir->GetDirectory(taskKey->GetName()) ; 
+                               AliInfo(Form("Saving %s", taskDir->GetName())) ; 
+                               TList * listTaskQAD = new TList() ; 
+                               listTaskQAD->SetName(taskKey->GetName()) ;
+                               listDetQAD->Add(listTaskQAD) ; 
+                               TList * histList = taskDir->GetListOfKeys() ; 
+                               TIter nextHist(histList) ; 
+                               TKey * histKey ; 
+                               while ( (histKey = dynamic_cast<TKey*>(nextHist())) ) {
+                                       TObject * odata = taskDir->Get(histKey->GetName()) ; 
+                                       if ( odata->IsA()->InheritsFrom("TH1") ) {
+                                               AliInfo(Form("Adding %s", histKey->GetName())) ;
+                                               TH1 * hdata = static_cast<TH1*>(odata) ; 
+                                               listTaskQAD->Add(hdata) ; 
+                                       }
+                               }
+                       }
+                       AliCDBMetaData mdr ;
+                       man->Put(listDetQAD, idr, &mdr) ;
+               }
+       }
+       return rv ; 
+}      

diff --git a/STEER/AliQADataMakerSteer.h b/STEER/AliQADataMakerSteer.h
index e084cae..cf4cd81 100644 (file)
--- a/STEER/AliQADataMakerSteer.h
+++ b/STEER/AliQADataMakerSteer.h
@@ -36,12 +36,15 @@ public:
        AliQADataMakerSteer(const AliQADataMakerSteer & qas) ; 
        AliQADataMakerSteer & operator = (const AliQADataMakerSteer & qas) ; 
        virtual ~AliQADataMakerSteer() ; 
-       Bool_t Merge() ;  
-    void   Reset() ;  
-       Bool_t Run(const char * detectors, const AliQA::TASKINDEX taskIndex, const char * fileName = NULL) ; 
-       Bool_t Run(const char * detectors, AliRawReader * rawReader) ; 
-       void   SetCycleLength(const AliQA::DETECTORINDEX det, const Int_t cycle) { fQACycles[det] = cycle ; }
-    void   SetRunLoader(AliRunLoader * rl) { fRunLoader = rl ; }
+    TList * GetFromOCDB(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task) const ; 
+       Bool_t  Merge(const Int_t runNumber = -1) const ;  
+    void    Reset() ;  
+       Bool_t  Run(const char * detectors, const AliQA::TASKINDEX taskIndex, const char * fileName = NULL) ; 
+       Bool_t  Run(const char * detectors, AliRawReader * rawReader) ; 
+    Bool_t  Save2OCDB(const Int_t runNumber, const Int_t cycleNumber, const char * detectors = "ALL") const ; 
+       void    SetCycleLength(const AliQA::DETECTORINDEX det, const Int_t cycle) { fQACycles[det] = cycle ; }
+    void    SetRunLoader(AliRunLoader * rl) { fRunLoader = rl ; }
+
 private: 
        Bool_t                   DoIt(const AliQA::TASKINDEX taskIndex) ;
        AliLoader      * GetLoader(Int_t iDet) ; 
@@ -51,6 +54,7 @@ private:
        Bool_t           InitRunLoader() ; 
        Bool_t           IsSelected(const char * detName)  ;
        Bool_t           Finish(const AliQA::TASKINDEX taskIndex) ;
+       Bool_t           SaveIt2OCDB(TFile * inputFile) const ;  
 
  
        Bool_t                     fCycleSame ;                    //! true if 2 consecutive data making for a same detector   

diff --git a/T0/AliT0QADataMaker.cxx b/T0/AliT0QADataMaker.cxx
index 21f6b37..f396327 100644 (file)
--- a/T0/AliT0QADataMaker.cxx
+++ b/T0/AliT0QADataMaker.cxx
@@ -90,7 +90,7 @@ AliT0QADataMaker& AliT0QADataMaker::operator = (const AliT0QADataMaker& qadm )
   return *this;
 }
 //____________________________________________________________________________
-void AliT0QADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TList * list)
+void AliT0QADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
@@ -117,7 +117,7 @@ void AliT0QADataMaker::InitHits()
       if(i<12)  fhHitsTime[i] = new TH1F(timename.Data(),timename.Data(),100,2000,3000);
       else  
        fhHitsTime[i] = new TH1F(timename.Data(),timename.Data(),100,12000,13000);
-      Add2HitsList( fhHitsTime[i],i);
+       Add2HitsList( fhHitsTime[i],i);
     }
   /*
   TH2F *fhHitsEffA = new TH2F("hHitsEffA", "Hits Efficiency A side", 25,-0.5,24.5, 100,12,13 );

diff --git a/T0/AliT0QADataMaker.h b/T0/AliT0QADataMaker.h
index 431a27b..da4bd6f 100644 (file)
--- a/T0/AliT0QADataMaker.h
+++ b/T0/AliT0QADataMaker.h
@@ -41,7 +41,7 @@ private:
   virtual void   MakeDigits(TTree* digitsTree) ;   //Fill Digit QA histo
   virtual void   MakeRecPoints(TTree * clusters)    ;  //Fill cluster QA histo
   virtual void   MakeESDs(AliESDEvent * esd) ;         //Fill hit QA histo
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TList * list) ;
+  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * list) ;
   virtual void   StartOfDetectorCycle() ;
   ClassDef(AliT0QADataMaker,1)  // description 
 

diff --git a/TOF/AliTOFQADataMaker.cxx b/TOF/AliTOFQADataMaker.cxx
index 65a7889..a55bab2 100644 (file)
--- a/TOF/AliTOFQADataMaker.cxx
+++ b/TOF/AliTOFQADataMaker.cxx
@@ -545,7 +545,7 @@ void AliTOFQADataMaker::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliTOFQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TList * list)
+void AliTOFQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking

diff --git a/TOF/AliTOFQADataMaker.h b/TOF/AliTOFQADataMaker.h
index 65cf41b..5b6dc7c 100644 (file)
--- a/TOF/AliTOFQADataMaker.h
+++ b/TOF/AliTOFQADataMaker.h
@@ -38,7 +38,7 @@ private:
   virtual void   MakeRecPoints(TTree * recTree) ; 
   virtual void   MakeRaws(AliRawReader* rawReader) ; 
   virtual void   StartOfDetectorCycle() ; 
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TList * list) ;
+  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * list) ;
   virtual void   GetMapIndeces(Int_t *in, Int_t *out) ; 
 
   ClassDef(AliTOFQADataMaker,1)  // description 

diff --git a/TRD/AliTRDQADataMaker.cxx b/TRD/AliTRDQADataMaker.cxx
index d2f5788..bb03180 100644 (file)
--- a/TRD/AliTRDQADataMaker.cxx
+++ b/TRD/AliTRDQADataMaker.cxx
@@ -86,7 +86,7 @@ AliTRDQADataMaker& AliTRDQADataMaker::operator=(const AliTRDQADataMaker& qadm)
 }
 
 //____________________________________________________________________________ 
-void AliTRDQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TList * list)
+void AliTRDQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list)
 {
   //
   // Detector specific actions at end of cycle

diff --git a/TRD/AliTRDQADataMaker.h b/TRD/AliTRDQADataMaker.h
index c7b8666..b0035a2 100644 (file)
--- a/TRD/AliTRDQADataMaker.h
+++ b/TRD/AliTRDQADataMaker.h
@@ -35,7 +35,7 @@ class AliTRDQADataMaker: public AliQADataMaker {
 
  private:
 
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX task, TList * list) ;
+  virtual void EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list) ;
   virtual void InitHits() ; 
   virtual void InitESDs() ; 
   virtual void InitDigits() ;