Fixes for bug #49914: Compilation breaks in trunk, and bug #48629: Trunk cannot read...
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 7 May 2009 10:50:59 +0000 (10:50 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 7 May 2009 10:50:59 +0000 (10:50 +0000)
147 files changed:
ACORDE/AliACORDEQAChecker.cxx
ACORDE/AliACORDEQAChecker.h
ACORDE/AliACORDEQADataMaker.cxx
ACORDE/AliACORDEQADataMaker.h
ACORDE/AliACORDEQADataMakerRec.cxx
ACORDE/AliACORDEQADataMakerRec.h
ACORDE/AliACORDEQADataMakerSim.cxx
ACORDE/AliACORDEQADataMakerSim.h
EMCAL/AliEMCALQAChecker.cxx
EMCAL/AliEMCALQADataMakerRec.cxx
EMCAL/AliEMCALQADataMakerRec.h
EMCAL/AliEMCALQADataMakerSim.cxx
EMCAL/AliEMCALQADataMakerSim.h
FMD/AliFMDQAChecker.cxx
FMD/AliFMDQADataMakerRec.cxx
FMD/AliFMDQADataMakerRec.h
FMD/AliFMDQADataMakerSim.cxx
FMD/AliFMDQADataMakerSim.h
HMPID/AliHMPIDQAChecker.cxx
HMPID/AliHMPIDQAChecker.h
HMPID/AliHMPIDQADataMaker.cxx
HMPID/AliHMPIDQADataMaker.h
HMPID/AliHMPIDQADataMakerRec.cxx
HMPID/AliHMPIDQADataMakerRec.h
HMPID/AliHMPIDQADataMakerSim.cxx
HMPID/AliHMPIDQADataMakerSim.h
HMPID/AliHMPIDRawStream.cxx
ITS/AliITSQAChecker.cxx
ITS/AliITSQAChecker.h
ITS/AliITSQADataMakerRec.cxx
ITS/AliITSQADataMakerRec.h
ITS/AliITSQADataMakerSim.cxx
ITS/AliITSQADataMakerSim.h
ITS/AliITSQASDDChecker.cxx
ITS/AliITSQASDDChecker.h
ITS/AliITSQASDDDataMakerRec.cxx
ITS/AliITSQASDDDataMakerRec.h
ITS/AliITSQASDDDataMakerSim.cxx
ITS/AliITSQASDDDataMakerSim.h
ITS/AliITSQASPDChecker.cxx
ITS/AliITSQASPDChecker.h
ITS/AliITSQASPDDataMakerRec.cxx
ITS/AliITSQASPDDataMakerRec.h
ITS/AliITSQASPDDataMakerSim.cxx
ITS/AliITSQASPDDataMakerSim.h
ITS/AliITSQASSDChecker.cxx
ITS/AliITSQASSDChecker.h
ITS/AliITSQASSDDataMakerRec.cxx
ITS/AliITSQASSDDataMakerRec.h
ITS/AliITSQASSDDataMakerSim.cxx
ITS/AliITSQASSDDataMakerSim.h
MUON/AliMUONPadStatusMaker.cxx
MUON/AliMUONQAChecker.cxx
MUON/AliMUONQAChecker.h
MUON/AliMUONQADataMakerRec.cxx
MUON/AliMUONQADataMakerRec.h
MUON/AliMUONQADataMakerSim.cxx
MUON/AliMUONQADataMakerSim.h
MUON/Doxymodules_STEER.h
MUON/runReconstruction.C
PHOS/AliPHOSQAChecker.cxx
PHOS/AliPHOSQADataMakerRec.cxx
PHOS/AliPHOSQADataMakerRec.h
PHOS/AliPHOSQADataMakerSim.cxx
PHOS/AliPHOSQADataMakerSim.h
PHOS/AliPHOSSDigitizer.cxx
PMD/AliPMDQAChecker.cxx
PMD/AliPMDQADataMakerRec.cxx
PMD/AliPMDQADataMakerRec.h
PMD/AliPMDQADataMakerSim.cxx
PMD/AliPMDQADataMakerSim.h
STEER/AliCorrQAChecker.cxx
STEER/AliCorrQAChecker.h
STEER/AliCorrQADataMakerRec.cxx
STEER/AliCorrQADataMakerRec.h
STEER/AliGlobalQAChecker.cxx
STEER/AliGlobalQADataMaker.cxx
STEER/AliGlobalQADataMaker.h
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.cxx
STEER/AliQADataMakerRec.h
STEER/AliQADataMakerSim.cxx
STEER/AliQADataMakerSim.h
STEER/AliQAManager.cxx
STEER/AliQAManager.h
STEER/AliQAv1.cxx [new file with mode: 0644]
STEER/AliQAv1.h [new file with mode: 0644]
STEER/AliReconstruction.cxx
STEER/AliReconstruction.h
STEER/AliSimulation.cxx
STEER/AliSimulation.h
STEER/CMake_libSTEER.txt
STEER/CMake_libSTEERBase.txt
STEER/STEERBaseLinkDef.h
STEER/STEERLinkDef.h
STEER/libSTEER.pkg
STEER/libSTEERBase.pkg
T0/AliT0QAChecker.cxx
T0/AliT0QAChecker.h
T0/AliT0QADataMaker.cxx
T0/AliT0QADataMaker.h
T0/AliT0QADataMakerRec.cxx
T0/AliT0QADataMakerRec.h
T0/AliT0QADataMakerSim.cxx
T0/AliT0QADataMakerSim.h
TOF/AliTOFQAChecker.cxx
TOF/AliTOFQAChecker.h
TOF/AliTOFQADataMaker.cxx
TOF/AliTOFQADataMaker.h
TOF/AliTOFQADataMakerRec.cxx
TOF/AliTOFQADataMakerRec.h
TOF/AliTOFQADataMakerSim.cxx
TOF/AliTOFQADataMakerSim.h
TPC/AliTPCQADataMakerRec.cxx
TPC/AliTPCQADataMakerRec.h
TPC/AliTPCQADataMakerSim.cxx
TPC/AliTPCQADataMakerSim.h
TRD/AliTRDQAChecker.cxx
TRD/AliTRDQAChecker.h
TRD/AliTRDQADataMaker.cxx
TRD/AliTRDQADataMaker.h
TRD/AliTRDQADataMakerRec.cxx
TRD/AliTRDQADataMakerRec.h
TRD/AliTRDQADataMakerSim.cxx
TRD/AliTRDQADataMakerSim.h
TRD/AliTRDqaRecPoints.cxx
VZERO/AliVZEROQAChecker.cxx
VZERO/AliVZEROQAChecker.h
VZERO/AliVZEROQADataMakerRec.cxx
VZERO/AliVZEROQADataMakerRec.h
VZERO/AliVZEROQADataMakerSim.cxx
VZERO/AliVZEROQADataMakerSim.h
ZDC/AliZDCQAChecker.cxx
ZDC/AliZDCQAChecker.h
ZDC/AliZDCQADataMaker.cxx
ZDC/AliZDCQADataMaker.h
ZDC/AliZDCQADataMakerRec.cxx
ZDC/AliZDCQADataMakerRec.h
ZDC/AliZDCQADataMakerSim.cxx
ZDC/AliZDCQADataMakerSim.h

index d4008bb..b8486de 100755 (executable)
@@ -33,7 +33,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliACORDEQAChecker.h"
 #include "AliCDBEntry.h"
@@ -42,7 +42,7 @@
 ClassImp(AliACORDEQAChecker)
 
 //____________________________________________________________________________
-Double_t * AliACORDEQAChecker::Check(AliQA::ALITASK_t /*index*/)
+Double_t * AliACORDEQAChecker::Check(AliQAv1::ALITASK_t /*index*/)
 {
   Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ; 
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
@@ -51,7 +51,7 @@ Double_t * AliACORDEQAChecker::Check(AliQA::ALITASK_t /*index*/)
 }
 
 //__________________________________________________________________
-Double_t * AliACORDEQAChecker::Check(AliQA::ALITASK_t /*index*/, TObjArray ** list)
+Double_t * AliACORDEQAChecker::Check(AliQAv1::ALITASK_t /*index*/, TObjArray ** list)
 {
 
        // We added one check to the ACORDE's QA histograms:
@@ -67,7 +67,7 @@ Double_t * AliACORDEQAChecker::Check(AliQA::ALITASK_t /*index*/, TObjArray ** li
 
        // Look at the QAref data for ACORDE
 
-       char * acoOCDBDir = Form("ACORDE/%s/%s",AliQA::GetRefOCDBDirName(),AliQA::GetRefDataDirName());
+       char * acoOCDBDir = Form("ACORDE/%s/%s",AliQAv1::GetRefOCDBDirName(),AliQAv1::GetRefDataDirName());
        AliCDBEntry *acoQARefDir = AliQAManager::QAManager()->Get(acoOCDBDir);
 
 
index c2607f5..0d8f403 100755 (executable)
@@ -30,8 +30,8 @@ public:
 //  AliACORDEQAChecker(const AliACORDEQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()) {;} // constructor   
   virtual ~AliACORDEQAChecker() {;} // destructor
 
-  virtual Double_t * Check(AliQA::ALITASK_t index) ;
-  virtual Double_t * Check(AliQA::ALITASK_t index, TObjArray ** list) ;
+  virtual Double_t * Check(AliQAv1::ALITASK_t index) ;
+  virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** list) ;
 
   Double_t CheckAcordeRefHits(TObjArray *AcordeList, TObjArray *AcordeRef) const;
 
index db8308f..2ab349f 100755 (executable)
@@ -51,7 +51,7 @@
 ClassImp(AliACORDEQADataMaker)
            
 //____________________________________________________________________________ 
-AliACORDEQADataMaker::AliACORDEQADataMaker():AliQADataMaker(AliQA::GetDetName(AliQA::kACORDE), "ACORDE Quality Assurance Data Maker")
+AliACORDEQADataMaker::AliACORDEQADataMaker():AliQADataMaker(AliQAv1::GetDetName(AliQAv1::kACORDE), "ACORDE Quality Assurance Data Maker")
 {
        // Acorde QA Data Maker
 }
index 98e19e7..9fb5b36 100755 (executable)
@@ -51,8 +51,8 @@ private:
   virtual Int_t  Add2RecPointsList(TH1*, Int_t){return 0;};
   virtual Int_t  Add2RawsList(TH1*, Int_t){return 0;};
   virtual Int_t  Add2SDigitsList(TH1*, Int_t){return 0;};
-  virtual void   Exec(AliQA::TASKINDEX_t, TObject*){};
-  virtual void   EndOfCycle(AliQA::TASKINDEX_t){};
+  virtual void   Exec(AliQAv1::TASKINDEX_t, TObject*){};
+  virtual void   EndOfCycle(AliQAv1::TASKINDEX_t){};
   virtual Int_t  Add2ESDsList(TH1*, Int_t){return 0;};
   virtual TH1*   GetDigitsData(Int_t){return 0;};
   virtual TH1*   GetESDsData(Int_t){return 0;};
@@ -60,10 +60,10 @@ private:
   virtual TH1*   GetRecPointsData(Int_t){return 0;};
   virtual TH1*   GetRawsData(Int_t){return 0;};
   virtual TH1*   GetSDigitsData(Int_t){return 0;};
-  virtual TObjArray* Init(AliQA::TASKINDEX_t, Int_t, Int_t){return 0;};
-  virtual void   Init(AliQA::TASKINDEX_t, TObjArray*, Int_t, Int_t){};
-  virtual void   StartOfCycle(AliQA::TASKINDEX_t, Bool_t){};
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray*){};
+  virtual TObjArray* Init(AliQAv1::TASKINDEX_t, Int_t, Int_t){return 0;};
+  virtual void   Init(AliQAv1::TASKINDEX_t, TObjArray*, Int_t, Int_t){};
+  virtual void   StartOfCycle(AliQAv1::TASKINDEX_t, Bool_t){};
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray*){};
   virtual void   InitSDigits(){};
   virtual void   MakeHits(TClonesArray*){};
   virtual void   MakeDigits(TClonesArray*){};
index acd8d9a..3b785bf 100755 (executable)
@@ -47,7 +47,7 @@
 ClassImp(AliACORDEQADataMakerRec)
            
 //____________________________________________________________________________ 
-AliACORDEQADataMakerRec::AliACORDEQADataMakerRec():AliQADataMakerRec(AliQA::GetDetName(AliQA::kACORDE), "ACORDE Quality Assurance Data Maker")
+AliACORDEQADataMakerRec::AliACORDEQADataMakerRec():AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kACORDE), "ACORDE Quality Assurance Data Maker")
 {
 
 }
@@ -66,11 +66,11 @@ AliACORDEQADataMakerRec& AliACORDEQADataMakerRec::operator = (const AliACORDEQAD
   return *this;
 }
 //____________________________________________________________________________
-void AliACORDEQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliACORDEQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kACORDE, task, list) ;
+  AliQAChecker::Instance()->Run(AliQAv1::kACORDE, task, list) ;
 }
 
 //____________________________________________________________________________
index 109a1e3..606527a 100755 (executable)
@@ -42,7 +42,7 @@ private:
   virtual void   InitESDs() ;      //book ESD QA histo 
   virtual void   MakeRaws(AliRawReader* rawReader) ;
   virtual void   MakeESDs(AliESDEvent * esd) ;         //Fill hit QA histo
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
   virtual void   StartOfDetectorCycle() ;
   ClassDef(AliACORDEQADataMakerRec,1)  // description 
 
index b4afb68..6ebe597 100755 (executable)
@@ -49,7 +49,7 @@
 ClassImp(AliACORDEQADataMakerSim)
            
 //____________________________________________________________________________ 
-AliACORDEQADataMakerSim::AliACORDEQADataMakerSim():AliQADataMakerSim(AliQA::GetDetName(AliQA::kACORDE), "ACORDE Quality Assurance Data Maker")
+AliACORDEQADataMakerSim::AliACORDEQADataMakerSim():AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kACORDE), "ACORDE Quality Assurance Data Maker")
 {
 }
 //____________________________________________________________________________ 
@@ -68,13 +68,13 @@ AliACORDEQADataMakerSim& AliACORDEQADataMakerSim::operator = (const AliACORDEQAD
   return *this;
 }
 //____________________________________________________________________________
-void AliACORDEQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliACORDEQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
    AliInfo("ACORDE---->Detector specific actions at END of cycle\n................\n");
 
-  AliQAChecker::Instance()->Run(AliQA::kACORDE, task, list) ;
+  AliQAChecker::Instance()->Run(AliQAv1::kACORDE, task, list) ;
 }
 //____________________________________________________________________________
 void AliACORDEQADataMakerSim::StartOfDetectorCycle()
index 5b92771..96483f6 100755 (executable)
@@ -43,7 +43,7 @@ private:
   virtual void   MakeHits(TClonesArray *) {}       //Dummy for the moment
   virtual void   MakeDigits(TTree* digitsTree) ;   //Fill Digit QA histo
   virtual void   MakeDigits(TClonesArray *) {}       //Dummy for the moment
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
   virtual void   StartOfDetectorCycle() ;
   ClassDef(AliACORDEQADataMakerSim,1)  // description 
 
index 519e7b8..d032630 100644 (file)
@@ -33,7 +33,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliEMCALQAChecker.h"
 
index 665a601..03ecd6f 100644 (file)
@@ -46,7 +46,7 @@ ClassImp(AliEMCALQADataMakerRec)
            
 //____________________________________________________________________________ 
   AliEMCALQADataMakerRec::AliEMCALQADataMakerRec() : 
-  AliQADataMakerRec(AliQA::GetDetName(AliQA::kEMCAL), "EMCAL Quality Assurance Data Maker")
+  AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kEMCAL), "EMCAL Quality Assurance Data Maker")
 {
   // ctor
 }
@@ -70,11 +70,11 @@ AliEMCALQADataMakerRec& AliEMCALQADataMakerRec::operator = (const AliEMCALQAData
 }
  
 //____________________________________________________________________________ 
-void AliEMCALQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliEMCALQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kEMCAL, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kEMCAL, task, list) ;  
 }
 
 //____________________________________________________________________________ 
index 4170d11..f89dd75 100644 (file)
@@ -44,7 +44,7 @@ public:
   virtual ~AliEMCALQADataMakerRec() {;} // dtor
   
 private:
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
   virtual void   InitESDs() ; 
   virtual void   InitRecPoints() ; 
   virtual void   InitRaws() ; 
index c0a973a..30a2e3d 100644 (file)
@@ -44,7 +44,7 @@ ClassImp(AliEMCALQADataMakerSim)
            
 //____________________________________________________________________________ 
   AliEMCALQADataMakerSim::AliEMCALQADataMakerSim() : 
-  AliQADataMakerSim(AliQA::GetDetName(AliQA::kEMCAL), "EMCAL Quality Assurance Data Maker")
+  AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kEMCAL), "EMCAL Quality Assurance Data Maker")
 {
   // ctor
 }
@@ -68,11 +68,11 @@ AliEMCALQADataMakerSim& AliEMCALQADataMakerSim::operator = (const AliEMCALQAData
 }
  
 //____________________________________________________________________________ 
-void AliEMCALQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliEMCALQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kEMCAL, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kEMCAL, task, list) ;  
 }
 
 //____________________________________________________________________________ 
index ea80847..2fc4f28 100644 (file)
@@ -31,7 +31,7 @@ public:
   virtual ~AliEMCALQADataMakerSim() {;} // dtor
   
 private:
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
   virtual void   InitHits() ; 
   virtual void   InitDigits() ; 
   virtual void   InitSDigits() ; 
index ad49e67..a695130 100644 (file)
@@ -34,7 +34,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliFMDQAChecker.h"
 
index ff36304..7bab963 100644 (file)
@@ -50,7 +50,7 @@ ClassImp(AliFMDQADataMakerRec)
            
 //_____________________________________________________________________
 AliFMDQADataMakerRec::AliFMDQADataMakerRec() : 
-  AliQADataMakerRec(AliQA::GetDetName(AliQA::kFMD), 
+  AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kFMD), 
                    "FMD Quality Assurance Data Maker"),
   fDigitsArray("AliFMDDigit", 0),
   fRecPointsArray("AliFMDRecPoint", 1000)
@@ -61,7 +61,7 @@ AliFMDQADataMakerRec::AliFMDQADataMakerRec() :
 
 //_____________________________________________________________________
 AliFMDQADataMakerRec::AliFMDQADataMakerRec(const AliFMDQADataMakerRec& qadm) 
-  : AliQADataMakerRec(AliQA::GetDetName(AliQA::kFMD), 
+  : AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kFMD), 
                      "FMD Quality Assurance Data Maker"),
     fDigitsArray(qadm.fDigitsArray),
     fRecPointsArray(qadm.fRecPointsArray)
@@ -89,7 +89,7 @@ AliFMDQADataMakerRec::~AliFMDQADataMakerRec()
 //_____________________________________________________________________ 
 
 void 
-AliFMDQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, 
+AliFMDQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, 
                                         TObjArray ** list)
 {
   // Detector specific actions at end of cycle
@@ -98,7 +98,7 @@ AliFMDQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task,
                  "AliFMDQADataMakerRec","AliFMDQADataMakerRec",
                  "AliFMDQADataMakerRec::EndOfDetectorCycle",
                  "AliFMDQADataMakerRec.cxx",95);
-  AliQAChecker::Instance()->Run(AliQA::kFMD, task, list);
+  AliQAChecker::Instance()->Run(AliQAv1::kFMD, task, list);
 }
 
 //_____________________________________________________________________ 
index d15dc89..58898d4 100644 (file)
@@ -26,7 +26,7 @@ public:
   AliFMDQADataMakerRec& operator = (const AliFMDQADataMakerRec& qadm) ;
   virtual ~AliFMDQADataMakerRec();
 private:
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list);
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list);
   virtual void   InitESDs(); 
   //  virtual void   InitDigits(); 
   virtual void   InitRecPoints(); 
index df3f81c..39c7680 100644 (file)
@@ -46,7 +46,7 @@ ClassImp(AliFMDQADataMakerSim)
 #endif
 //_____________________________________________________________________
 AliFMDQADataMakerSim::AliFMDQADataMakerSim() 
-  :  AliQADataMakerSim(AliQA::GetDetName(AliQA::kFMD),
+  :  AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kFMD),
                       "FMD Quality Assurance Data Maker"),
      fSDigitsArray("AliFMDSDigit", 1000),
      fDigitsArray("AliFMDDigit", 1000),
@@ -85,7 +85,7 @@ AliFMDQADataMakerSim::~AliFMDQADataMakerSim()
 }
 
 //_____________________________________________________________________
-void AliFMDQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, 
+void AliFMDQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, 
                                              TObjArray ** list)
 {
   //Detector specific actions at end of cycle
@@ -94,7 +94,7 @@ void AliFMDQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task,
                  "AliFMDQADataMakerSim","AliFMDQADataMakerSim",
                  "AliFMDQADataMakerSim::EndOfDetectorCycle",
                  "AliFMDQADataMakerSim.cxx",83);
-  AliQAChecker::Instance()->Run(AliQA::kFMD, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kFMD, task, list) ;  
   
 }
 //_____________________________________________________________________
index 2038571..951608c 100644 (file)
@@ -29,7 +29,7 @@ class AliFMDQADataMakerSim: public AliQADataMakerSim {
   virtual ~AliFMDQADataMakerSim();  // dtor
   
  private:
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list);
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list);
   virtual void   InitHits(); 
   virtual void   InitDigits(); 
   // virtual void   InitRaws() ; 
index 7648ef1..25d398e 100644 (file)
@@ -35,7 +35,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliHMPIDQAChecker.h"
 #include "AliCDBEntry.h"
@@ -44,7 +44,7 @@
 ClassImp(AliHMPIDQAChecker)
 
 //____________________________________________________________________________
-Double_t * AliHMPIDQAChecker::Check(AliQA::ALITASK_t /*index*/)
+Double_t * AliHMPIDQAChecker::Check(AliQAv1::ALITASK_t /*index*/)
 {
   Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ; 
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
@@ -53,7 +53,7 @@ Double_t * AliHMPIDQAChecker::Check(AliQA::ALITASK_t /*index*/)
 }
 
 //_________________________________________________________________
-Double_t * AliHMPIDQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list) 
+Double_t * AliHMPIDQAChecker::Check(AliQAv1::ALITASK_t index, TObjArray ** list) 
 {
 //
 // Main check function: Depending on the TASK, different checks are applied
@@ -62,7 +62,7 @@ Double_t * AliHMPIDQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
   Double_t * check = new Double_t[AliRecoParam::kNSpecies] ; 
   
   AliInfo(Form("Fix needed ....."));
-  char * detOCDBDir = Form("HMPID/%s/%s", AliQA::GetRefOCDBDirName(), AliQA::GetRefDataDirName()) ; 
+  char * detOCDBDir = Form("HMPID/%s/%s", AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName()) ; 
   AliCDBEntry *QARefRec = AliQAManager::QAManager()->Get(detOCDBDir);
   if( !QARefRec){
     AliInfo("QA reference data NOT retrieved for Reconstruction check. No HMPIDChecker  ...exiting");
@@ -72,7 +72,7 @@ Double_t * AliHMPIDQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
 // checking for empy histograms
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
     check[specie] = 1.0;
-    if ( !AliQA::Instance()->IsEventSpecieSet(specie) ) 
+    if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) 
       continue ; 
     if(CheckEntries(list[specie]) == 0)  {
       AliWarning("histograms are empty");
@@ -80,7 +80,7 @@ Double_t * AliHMPIDQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
     }
   
     // checking rec points
-    if(index == AliQA::kREC) check[specie] = CheckRecPoints(list[specie],(TObjArray *)QARefRec->GetObject());
+    if(index == AliQAv1::kREC) check[specie] = CheckRecPoints(list[specie],(TObjArray *)QARefRec->GetObject());
 
     //default check response. It will be changed when reasonable checks will be considered
     else check[specie] = 0.7 ; // /-> Corresponds to kINFO see AliQACheckerBase::Run 
index 73182e1..f07973e 100644 (file)
@@ -30,8 +30,8 @@ public:
   AliHMPIDQAChecker(const AliHMPIDQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()) {;} // cpy ctor   
   virtual ~AliHMPIDQAChecker() {;} // dtor
 
-  virtual Double_t * Check(AliQA::ALITASK_t /*index*/) ;
-  virtual Double_t * Check(AliQA::ALITASK_t index, TObjArray ** list) ;
+  virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/) ;
+  virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** list) ;
   
   Double_t CheckEntries(TObjArray * list) const ;
   Double_t CheckRecPoints(TObjArray *listrec, TObjArray *listref) const ;
index 991e05d..a50547e 100644 (file)
@@ -41,7 +41,7 @@ ClassImp(AliHMPIDQADataMaker)
            
 //____________________________________________________________________________ 
   AliHMPIDQADataMaker::AliHMPIDQADataMaker() : 
-  AliQADataMaker(AliQA::GetDetName(AliQA::kHMPID), "HMPID Quality Assurance Data Maker")
+  AliQADataMaker(AliQAv1::GetDetName(AliQAv1::kHMPID), "HMPID Quality Assurance Data Maker")
 {
   // ctor
 }
@@ -380,10 +380,10 @@ void AliHMPIDQADataMaker::StartOfDetectorCycle()
   
 }
 
-void AliHMPIDQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * obj)
+void AliHMPIDQADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX task, TObjArray * obj)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-//  AliQAChecker::Instance()->Run(AliQA::kHMPID, task, obj) ;  
+//  AliQAChecker::Instance()->Run(AliQAv1::kHMPID, task, obj) ;  
 }
 
index 0146d4c..07355d6 100644 (file)
@@ -36,7 +36,7 @@ public:
 
 private:
 
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * obj) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX, TObjArray * obj) ;
   virtual void   InitHits() ;      //book hit QA histo 
   virtual void   InitDigits() ;    //book Digit QA histo
   virtual void   InitSDigits() ;   //book SDigits QA histo
index 63a64d8..4f1bb17 100644 (file)
@@ -49,7 +49,7 @@ ClassImp(AliHMPIDQADataMakerRec)
            
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   AliHMPIDQADataMakerRec::AliHMPIDQADataMakerRec() : 
-  AliQADataMakerRec(AliQA::GetDetName(AliQA::kHMPID), "HMPID Quality Assurance Data Maker"),fEvtRaw(0)
+  AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kHMPID), "HMPID Quality Assurance Data Maker"),fEvtRaw(0)
 {
   // ctor
 }
@@ -274,12 +274,12 @@ void AliHMPIDQADataMakerRec::StartOfDetectorCycle()
 }
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
-void AliHMPIDQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray **histos)
+void AliHMPIDQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray **histos)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
   
-  if(task==AliQA::kRAWS) {
+  if(task==AliQAv1::kRAWS) {
     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
       for(Int_t iddl=0;iddl<14;iddl++) {
         TH1F *h = (TH1F*)histos[specie]->At(14+iddl); //ddl histos scaled by the number of events 
@@ -288,7 +288,7 @@ void AliHMPIDQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArr
     }
   }
   
-   AliQAChecker::Instance()->Run(AliQA::kHMPID, task, histos);
+   AliQAChecker::Instance()->Run(AliQAv1::kHMPID, task, histos);
 
 }
 
index 0f4fdad..bcae699 100644 (file)
@@ -37,7 +37,7 @@ private:
   virtual void   MakeRaws(AliRawReader* rawReader);
   virtual void   MakeESDs(AliESDEvent * esd) ;         //Fill hit QA histo
   virtual void   StartOfDetectorCycle() ;
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** obj) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** obj) ;
   Int_t   fEvtRaw;    //internal event counter for raw 
 
   ClassDef(AliHMPIDQADataMakerRec,1)  // description 
index ac1e1b5..6776268 100644 (file)
@@ -47,7 +47,7 @@ ClassImp(AliHMPIDQADataMakerSim)
            
 //____________________________________________________________________________ 
   AliHMPIDQADataMakerSim::AliHMPIDQADataMakerSim() : 
-  AliQADataMakerSim(AliQA::GetDetName(AliQA::kHMPID), "HMPID Quality Assurance Data Maker")
+  AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kHMPID), "HMPID Quality Assurance Data Maker")
 {
   // ctor
 }
@@ -239,10 +239,10 @@ void AliHMPIDQADataMakerSim::StartOfDetectorCycle()
   
 }
 
-void AliHMPIDQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray **obj)
+void AliHMPIDQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray **obj)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kHMPID, task, obj) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kHMPID, task, obj) ;  
 }
 
index ca1c581..9986047 100644 (file)
@@ -35,7 +35,7 @@ public:
 
 private:
 
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** obj) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** obj) ;
   virtual void   InitHits() ;      //book hit QA histo 
   virtual void   InitDigits() ;    //book Digit QA histo
   virtual void   InitSDigits() ;   //book SDigits QA histo
index 45c528b..1b01269 100644 (file)
@@ -495,7 +495,7 @@ Bool_t AliHMPIDRawStream::CheckEoE(Int_t &nDil)
 //    fRawReader->AddMajorErrorLog(kEoEDILOGICErr,Form("eoe dil %d != %d",da,dilogic));
 //    AliDebug(1,Form("Wrong DILOGIC address found in end-of-event: %d, expected %d!",da,dilogic));
 //    fNumOfErr[kEoEDILOGICErr]++;
-//    return kFALSE;  AliQAChecker::Instance()->Run(AliQA::kHMPID, task, obj) ;  
+//    return kFALSE;  AliQAChecker::Instance()->Run(AliQAv1::kHMPID, task, obj) ;  
 
 //  }
 //  UInt_t ca = (eOfEvent >> 22) & 0x1f;
index 2b11813..2f5ec93 100644 (file)
@@ -84,7 +84,7 @@ AliITSQAChecker& AliITSQAChecker::operator=(const AliITSQAChecker& qac){
 }
 
 //____________________________________________________________________________
-Double_t * AliITSQAChecker::Check(AliQA::ALITASK_t /*index*/)
+Double_t * AliITSQAChecker::Check(AliQAv1::ALITASK_t /*index*/)
 {
   Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ; 
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
@@ -93,16 +93,16 @@ Double_t * AliITSQAChecker::Check(AliQA::ALITASK_t /*index*/)
 }
 
 //____________________________________________________________________________
-Double_t * AliITSQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
+Double_t * AliITSQAChecker::Check(AliQAv1::ALITASK_t index, TObjArray ** list)
 {
   
   // Super-basic check on the QA histograms on the input list:
   // look whether they are empty!
-  if(index == AliQA::kESD){
+  if(index == AliQAv1::kESD){
     Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ; 
     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
       rv[specie] = 0.0 ; 
-      if ( !AliQA::Instance()->IsEventSpecieSet(specie) ) 
+      if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) 
         continue ; 
       AliDebug(1,"Checker for ESD");
       Int_t tested = 0;
@@ -248,7 +248,7 @@ Double_t * AliITSQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
     fSPDChecker->SetTaskOffset(fSPDOffset);
     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
       retval[specie] = 1.0 ; 
-      if ( AliQA::Instance()->IsEventSpecieSet(specie) ) {
+      if ( AliQAv1::Instance()->IsEventSpecieSet(specie) ) {
         spdCheck = fSPDChecker->Check(index, list[specie]);
         if(spdCheck<retval[specie])retval[specie] = spdCheck;
       }
@@ -263,7 +263,7 @@ Double_t * AliITSQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
     fSDDChecker->SetTaskOffset(fSDDOffset);
     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
       retval[specie] = 1.0 ; 
-      if ( AliQA::Instance()->IsEventSpecieSet(specie) ) {
+      if ( AliQAv1::Instance()->IsEventSpecieSet(specie) ) {
         sddCheck = fSDDChecker->Check(index, list[specie]);
         if(sddCheck<retval[specie])retval[specie] = sddCheck;
       }
@@ -279,7 +279,7 @@ Double_t * AliITSQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
     fSSDChecker->SetTaskOffset(fSSDOffset);
     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
       retval[specie] = 1.0 ; 
-      if ( AliQA::Instance()->IsEventSpecieSet(specie) ) {
+      if ( AliQAv1::Instance()->IsEventSpecieSet(specie) ) {
         ssdCheck = fSSDChecker->Check(index, list[specie]);
         if(ssdCheck<retval[specie])retval[specie] = ssdCheck;  
       }
index 48a17ab..daa0792 100644 (file)
@@ -19,7 +19,7 @@ class TFile ;
 class TH2F ;  
 
 // --- AliRoot header files ---
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQACheckerBase.h"
 
 class AliITSQASPDChecker;
@@ -48,8 +48,8 @@ public:
   virtual void SetDetTaskOffset(Int_t subdet=0,Int_t offset=0);
 
 protected:
-  virtual Double_t * Check(AliQA::ALITASK_t /*index*/) ;
-  virtual Double_t * Check(AliQA::ALITASK_t index, TObjArray ** list ) ;
+  virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/) ;
+  virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** list ) ;
   virtual void SetSPDTaskOffset(Int_t SPDOffset){fSPDOffset = SPDOffset;} ;
   virtual void SetSDDTaskOffset(Int_t SDDOffset){fSDDOffset = SDDOffset;} ;
   virtual void SetSSDTaskOffset(Int_t SSDOffset){fSSDOffset = SSDOffset;} ;
index 78dc327..e80251d 100644 (file)
@@ -34,7 +34,7 @@
 #include "AliITSQASDDDataMakerRec.h"
 #include "AliITSQASSDDataMakerRec.h"
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliITSQAChecker.h"
 #include "AliRawReader.h"
@@ -47,7 +47,7 @@ ClassImp(AliITSQADataMakerRec)
 
 //____________________________________________________________________________ 
 AliITSQADataMakerRec::AliITSQADataMakerRec(Bool_t kMode, Short_t subDet, Short_t ldc) :
-AliQADataMakerRec(AliQA::GetDetName(AliQA::kITS), "ITS Quality Assurance Data Maker"),
+AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kITS), "ITS Quality Assurance Data Maker"),
 fkOnline(kMode),
 fHLTMode(0),
 fSubDetector(subDet),
@@ -121,13 +121,13 @@ void AliITSQADataMakerRec::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliITSQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray** list)
+void AliITSQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list)
 {
   // launch the QA checking
 
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
     SetEventSpecie(specie) ; 
-    AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list[specie])\n"); 
+    AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list[specie])\n"); 
     if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->EndOfDetectorCycle(task, list[specie]);
     if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->EndOfDetectorCycle(task, list[specie]);
     if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->EndOfDetectorCycle(task, list[specie]);
@@ -147,7 +147,7 @@ void AliITSQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray
        qacb->SetDetTaskOffset(subdet,offset);
       }
 
-    qac->Run( AliQA::kITS , task, list); 
+    qac->Run( AliQAv1::kITS , task, list); 
 
   }
 }
@@ -462,7 +462,7 @@ void AliITSQADataMakerRec::MakeESDs(AliESDEvent *esd)
 }
 
 //_________________________________________________________________
-Int_t AliITSQADataMakerRec::GetDetTaskOffset(Int_t subdet,AliQA::TASKINDEX_t task)
+Int_t AliITSQADataMakerRec::GetDetTaskOffset(Int_t subdet,AliQAv1::TASKINDEX_t task)
 {
   switch(subdet)
     {
index fe25b7d..a8948d0 100644 (file)
@@ -36,7 +36,7 @@ public:
   AliITSQADataMakerRec(const AliITSQADataMakerRec& qadm);
   AliITSQADataMakerRec& operator = (const AliITSQADataMakerRec& qac);
   virtual void StartOfDetectorCycle();
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list);
+  virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list);
   virtual void EndOfDetectorCycle(const char *fgDataName);
   virtual void InitRaws();
   virtual void InitRecPoints();
@@ -49,7 +49,7 @@ public:
   Bool_t GetHLTMode(){return fHLTMode;};
   virtual ~AliITSQADataMakerRec(); // dtor
  Short_t GetSubDet(){return fSubDetector;};
- Int_t GetDetTaskOffset(Int_t subdet,AliQA::TASKINDEX_t task);
+ Int_t GetDetTaskOffset(Int_t subdet,AliQAv1::TASKINDEX_t task);
 
 
 private:
index 1e2f65a..6035f93 100644 (file)
@@ -34,7 +34,7 @@
 #include "AliITSQASDDDataMakerSim.h"
 #include "AliITSQASSDDataMakerSim.h"
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliITSQAChecker.h"
 #include "AliRawReader.h"
@@ -43,7 +43,7 @@ ClassImp(AliITSQADataMakerSim)
 
 //____________________________________________________________________________ 
 AliITSQADataMakerSim::AliITSQADataMakerSim(Short_t subDet) :
-AliQADataMakerSim(AliQA::GetDetName(AliQA::kITS), "ITS Quality Assurance Data Maker"),
+AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kITS), "ITS Quality Assurance Data Maker"),
 fSubDetector(subDet),
 fSPDDataMaker(NULL),
 fSDDDataMaker(NULL),
@@ -112,12 +112,12 @@ void AliITSQADataMakerSim::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliITSQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray** list)
+void AliITSQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list)
 {
   // launch the QA checking
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
     SetEventSpecie(specie) ; 
-    AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); 
+    AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n"); 
     if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->EndOfDetectorCycle(task, list[specie]);
     if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->EndOfDetectorCycle(task, list[specie]);
     if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->EndOfDetectorCycle(task, list[specie]);
@@ -136,7 +136,7 @@ void AliITSQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray
        Int_t offset=GetDetTaskOffset(subdet, task);
        qacb->SetDetTaskOffset(subdet,offset);
       }
-    qac->Run( AliQA::kITS , task, list); 
+    qac->Run( AliQAv1::kITS , task, list); 
   }
 }
 
@@ -250,7 +250,7 @@ void AliITSQADataMakerSim::MakeHits(TTree * hits)
 
 //_________________________________________________________________
 
-Int_t AliITSQADataMakerSim::GetDetTaskOffset(Int_t subdet,AliQA::TASKINDEX_t task)
+Int_t AliITSQADataMakerSim::GetDetTaskOffset(Int_t subdet,AliQAv1::TASKINDEX_t task)
 {
   switch(subdet)
     {
index a2448d0..8bf2d16 100644 (file)
@@ -31,7 +31,7 @@ public:
   AliITSQADataMakerSim(const AliITSQADataMakerSim& qadm);
   AliITSQADataMakerSim& operator = (const AliITSQADataMakerSim& qac);
   virtual void StartOfDetectorCycle();
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list);
+  virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list);
   virtual void InitDigits();
   virtual void InitSDigits();
   virtual void InitHits();
@@ -43,7 +43,7 @@ public:
   virtual void MakeHits(TTree * hits);
   virtual ~AliITSQADataMakerSim(); // dtor
   Short_t GetSubDet(){return fSubDetector;};
-  Int_t GetDetTaskOffset(Int_t subdet,AliQA::TASKINDEX_t task);
+  Int_t GetDetTaskOffset(Int_t subdet,AliQAv1::TASKINDEX_t task);
 
 private:
 
index bee0be9..ac88b74 100644 (file)
@@ -46,10 +46,10 @@ AliITSQASDDChecker& AliITSQASDDChecker::operator = (const AliITSQASDDChecker& qa
 }
 
 //__________________________________________________________________
-Double_t AliITSQASDDChecker::Check(AliQA::ALITASK_t index, TObjArray * list) 
+Double_t AliITSQASDDChecker::Check(AliQAv1::ALITASK_t index, TObjArray * list) 
 {  
   AliDebug(1,Form("AliITSQASDDChecker called with offset: %d\n", fSubDetOffset));
-  char * detOCDBDir = Form("ITS/%s/%s", AliQA::GetRefOCDBDirName(), AliQA::GetRefDataDirName()) ; 
+  char * detOCDBDir = Form("ITS/%s/%s", AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName()) ; 
   AliCDBEntry *QARefObj = AliQAManager::QAManager()->Get(detOCDBDir);
   if( !QARefObj){
     AliError("Calibration object retrieval failed! SDD will not be processed");
@@ -59,7 +59,7 @@ Double_t AliITSQASDDChecker::Check(AliQA::ALITASK_t index, TObjArray * list)
   Double_t test = 0.0;
   Int_t offset = 0;
 
-  if(index==AliQA::kRAW){  //analizing RAWS
+  if(index==AliQAv1::kRAW){  //analizing RAWS
     TH1F *ModPattern = (TH1F*)QARefObj->GetObject();
     if (list->GetEntries() == 0){
       test = 1. ; // nothing to check
@@ -95,7 +95,7 @@ Double_t AliITSQASDDChecker::Check(AliQA::ALITASK_t index, TObjArray * list)
   } // if(index==0)
 
   
-  if( index==AliQA::kREC){ //analizing RECP
+  if( index==AliQAv1::kREC){ //analizing RECP
     //printf("analizing recp, offset %d \n",fSubDetOffset);
     if (list->GetEntries() == 0){
       test = 1. ; // nothing to check
index 020d3f1..3e2a3da 100644 (file)
@@ -19,7 +19,7 @@ class TFile ;
 class TH2F ;  
 
 // --- AliRoot header files ---
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQACheckerBase.h"
 #include "AliITSQAChecker.h"
 class AliITSLoader ; 
@@ -30,7 +30,7 @@ public:
   AliITSQASDDChecker():fSubDetOffset(0) {;}          // ctor
   AliITSQASDDChecker& operator = (const AliITSQASDDChecker& qac) ; //operator =
   virtual ~AliITSQASDDChecker() {;} // dtor
-  Double_t Check(AliQA::ALITASK_t index, TObjArray * list);
+  Double_t Check(AliQAv1::ALITASK_t index, TObjArray * list);
   void SetTaskOffset(Int_t TaskOffset);
 
 private:
index 6ee9494..a13d82f 100644 (file)
@@ -39,7 +39,7 @@
 // --- AliRoot header files ---
 #include "AliITSQASDDDataMakerRec.h"
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliRawReader.h"
 #include "AliITSRawStream.h"
@@ -127,10 +127,10 @@ void AliITSQASDDDataMakerRec::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliITSQASDDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TObjArray* /*list*/)
+void AliITSQASDDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)
 {
   // launch the QA checking
-  AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); 
+  AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n"); 
 }
 
 //____________________________________________________________________________ 
@@ -618,15 +618,15 @@ void AliITSQASDDDataMakerRec::SetHLTModeFromEnvironment()
 
 //_______________________________________________________________
 
-Int_t AliITSQASDDDataMakerRec::GetOffset(AliQA::TASKINDEX_t task)
+Int_t AliITSQASDDDataMakerRec::GetOffset(AliQAv1::TASKINDEX_t task)
 {
   Int_t offset=0;
-  if( task == AliQA::kRAWS )
+  if( task == AliQAv1::kRAWS )
     {
       offset=fGenRawsOffset;  
     }
   else
-    if( task == AliQA::kRECPOINTS )
+    if( task == AliQAv1::kRECPOINTS )
       {
        offset=fGenRecPointsOffset;   
       }
@@ -636,17 +636,17 @@ Int_t AliITSQASDDDataMakerRec::GetOffset(AliQA::TASKINDEX_t task)
 
 //_______________________________________________________________
 
-Int_t AliITSQASDDDataMakerRec::GetTaskHisto(AliQA::TASKINDEX_t task)
+Int_t AliITSQASDDDataMakerRec::GetTaskHisto(AliQAv1::TASKINDEX_t task)
 {
 
   Int_t histotot=0;
 
-  if( task == AliQA::kRAWS )
+  if( task == AliQAv1::kRAWS )
     {
       histotot=fSDDhRawsTask ;  
     }
   else
-    if( task == AliQA::kRECPOINTS )
+    if( task == AliQAv1::kRECPOINTS )
       {
        histotot=fSDDhRecPointsTask;   
       }
index 8462171..4f56534 100644 (file)
@@ -14,7 +14,7 @@
 
 /* $Id$ */
 
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliITSQADataMakerRec.h"
 
 class TObjArray;
@@ -31,12 +31,12 @@ public:
   virtual void MakeRaws(AliRawReader *rawReader);
   virtual void MakeRecPoints(TTree *clustersTree);
   virtual void StartOfDetectorCycle();
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);
+  virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
 
 
   virtual ~AliITSQASDDDataMakerRec(); // dtor
-  Int_t GetOffset(AliQA::TASKINDEX_t task);
-  Int_t GetTaskHisto(AliQA::TASKINDEX_t task);
+  Int_t GetOffset(AliQAv1::TASKINDEX_t task);
+  Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);
 
   void SetHLTMode(Bool_t khltmode=kFALSE){fHLTMode=khltmode;};
   Bool_t GetHLTMode(){return fHLTMode;};
index cd2e25d..2e63f2b 100644 (file)
@@ -30,7 +30,7 @@
 // --- AliRoot header files ---\r
 #include "AliITSQASDDDataMakerSim.h"\r
 #include "AliLog.h"\r
-#include "AliQA.h"\r
+#include "AliQAv1.h"\r
 #include "AliQAChecker.h"\r
 #include "AliQADataMakerSim.h"\r
 #include "AliITSQADataMakerSim.h"\r
@@ -94,11 +94,11 @@ void AliITSQASDDDataMakerSim::StartOfDetectorCycle()
 }\r
 \r
 //____________________________________________________________________________ \r
-void AliITSQASDDDataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TObjArray* /*list*/)\r
+void AliITSQASDDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)\r
 {\r
   // launch the QA checking\r
-  AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); \r
-  //AliQAChecker::Instance()->Run( AliQA::kITS , task, list);\r
+  AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n"); \r
+  //AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);\r
 }\r
 \r
 //____________________________________________________________________________ \r
@@ -298,16 +298,16 @@ void AliITSQASDDDataMakerSim::MakeHits(TTree * hits)
 \r
 //_______________________________________________________________\r
 \r
-Int_t AliITSQASDDDataMakerSim::GetOffset(AliQA::TASKINDEX_t task){\r
+Int_t AliITSQASDDDataMakerSim::GetOffset(AliQAv1::TASKINDEX_t task){\r
   // Returns histogram offset according to the specified task\r
   Int_t offset=0;\r
-  if( task == AliQA::kHITS){\r
+  if( task == AliQAv1::kHITS){\r
     offset=fGenOffsetH;  \r
   }\r
-  else if( task == AliQA::kSDIGITS) {\r
+  else if( task == AliQAv1::kSDIGITS) {\r
     offset=fGenOffsetS;   \r
   }\r
-  else if( task == AliQA::kDIGITS) {\r
+  else if( task == AliQAv1::kDIGITS) {\r
     offset=fGenOffsetD;   \r
   }\r
   else {\r
@@ -320,16 +320,16 @@ Int_t AliITSQASDDDataMakerSim::GetOffset(AliQA::TASKINDEX_t task){
 \r
 //_______________________________________________________________\r
 \r
-Int_t AliITSQASDDDataMakerSim::GetTaskHisto(AliQA::TASKINDEX_t task) {\r
+Int_t AliITSQASDDDataMakerSim::GetTaskHisto(AliQAv1::TASKINDEX_t task) {\r
   // Returns the number of booked histograms for the selected task\r
   Int_t histotot=0;\r
-  if( task == AliQA::kHITS) {\r
+  if( task == AliQAv1::kHITS) {\r
     histotot=fSDDhHTask ;  \r
   }\r
-  else if( task == AliQA::kSDIGITS) {\r
+  else if( task == AliQAv1::kSDIGITS) {\r
     histotot=fSDDhSTask;   \r
   }\r
-  else if( task == AliQA::kDIGITS) {\r
+  else if( task == AliQAv1::kDIGITS) {\r
     histotot=fSDDhDTask ;   \r
   }\r
   else {\r
index a8de8f4..eb064b4 100644 (file)
@@ -14,7 +14,7 @@
 \r
 /* $Id$ */\r
 \r
-#include "AliQA.h"\r
+#include "AliQAv1.h"\r
 class AliITSQADataMakerSim;\r
 class AliRunLoader;\r
 class AliRun;\r
@@ -29,7 +29,7 @@ public:
   AliITSQASDDDataMakerSim& operator = (const AliITSQASDDDataMakerSim& qac);\r
 \r
   virtual void StartOfDetectorCycle();\r
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);\r
+  virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);\r
   virtual ~AliITSQASDDDataMakerSim() {;}   // dtor\r
   virtual void InitDigits();\r
   virtual void InitSDigits();\r
@@ -40,8 +40,8 @@ public:
   virtual void MakeDigits(TTree * digits);\r
   virtual void MakeSDigits(TTree * sdigits);\r
   virtual void MakeHits(TTree * hits);\r
-  Int_t GetOffset(AliQA::TASKINDEX_t task);\r
-  Int_t GetTaskHisto(AliQA::TASKINDEX_t task);\r
+  Int_t GetOffset(AliQAv1::TASKINDEX_t task);\r
+  Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);\r
 \r
 private:\r
 \r
index 1270319..7b3ecbc 100644 (file)
@@ -41,7 +41,7 @@ AliITSQASPDChecker& AliITSQASPDChecker::operator = (const AliITSQASPDChecker& qa
 
 
 //__________________________________________________________________
-Double_t AliITSQASPDChecker::Check(AliQA::ALITASK_t /*index*/, TObjArray * list)
+Double_t AliITSQASPDChecker::Check(AliQAv1::ALITASK_t /*index*/, TObjArray * list)
 {
   AliDebug(1,Form("AliITSQASPDChecker called with offset: %d\n", fSubDetOffset));
 
index d5b2890..e5a5484 100644 (file)
@@ -19,7 +19,7 @@ class TFile ;
 class TH2F ;  
 
 // --- AliRoot header files ---
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQACheckerBase.h"
 #include "AliITSQAChecker.h"
 class AliITSLoader ; 
@@ -30,7 +30,7 @@ public:
   AliITSQASPDChecker():fSubDetOffset(0) {;}          // ctor
   AliITSQASPDChecker& operator = (const AliITSQASPDChecker& qac) ; //operator =
   virtual ~AliITSQASPDChecker() {;} // dtor
-  Double_t Check(AliQA::ALITASK_t index, TObjArray * list);
+  Double_t Check(AliQAv1::ALITASK_t index, TObjArray * list);
   void SetTaskOffset(Int_t TaskOffset);
 private:
   
index 2c05aca..ae96474 100644 (file)
@@ -35,7 +35,7 @@
 #include "AliITSQADataMakerRec.h"
 #include "AliITSQASPDDataMakerRec.h"
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliRawReader.h"
 #include "AliITSRawStreamSPD.h"
 #include "AliITSRawStreamSPDErrorLog.h"
@@ -98,12 +98,12 @@ void AliITSQASPDDataMakerRec::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliITSQASPDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TObjArray* /*list*/)
+void AliITSQASPDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)
 {
   // launch the QA checking
-  AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); 
+  AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n"); 
   
-  //AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
+  //AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);
 }
 
 //____________________________________________________________________________ 
@@ -448,13 +448,13 @@ void AliITSQASPDDataMakerRec::MakeRecPoints(TTree * clusterTree)
 
 //_______________________________________________________________
 
-Int_t AliITSQASPDDataMakerRec::GetOffset(AliQA::TASKINDEX_t task) {
+Int_t AliITSQASPDDataMakerRec::GetOffset(AliQAv1::TASKINDEX_t task) {
   // Returns offset number according to the specified task
   Int_t offset=0;
-  if( task == AliQA::kRAWS ) {
+  if( task == AliQAv1::kRAWS ) {
     offset=fGenRawsOffset;
   }
-  else if( task == AliQA::kRECPOINTS ) {
+  else if( task == AliQAv1::kRECPOINTS ) {
     offset=fGenRecPointsOffset;
   }
   else {
@@ -466,14 +466,14 @@ Int_t AliITSQASPDDataMakerRec::GetOffset(AliQA::TASKINDEX_t task) {
 
 //_______________________________________________________________
 
-Int_t AliITSQASPDDataMakerRec::GetTaskHisto(AliQA::TASKINDEX_t task) {
+Int_t AliITSQASPDDataMakerRec::GetTaskHisto(AliQAv1::TASKINDEX_t task) {
   // Returns the number of histograms associated to the specified task
   Int_t histotot=0;
 
-  if( task == AliQA::kRAWS ) {
+  if( task == AliQAv1::kRAWS ) {
     histotot=fSPDhRawsTask;
   }
-  else if( task == AliQA::kRECPOINTS ){
+  else if( task == AliQAv1::kRECPOINTS ){
     histotot=fSPDhRecPointsTask;
   }
   else {
index 5720972..86ed213 100644 (file)
@@ -19,7 +19,7 @@ class TObjArray;
 class AliRawReader;
 class AliITSRawStreamSPDErrorLog;
 class AliITSQADataMakerRec;
-class AliQA;
+class AliQAv1;
 
 class AliITSQASPDDataMakerRec : public TObject {
 
@@ -33,10 +33,10 @@ public:
   virtual void MakeRaws(AliRawReader *rawReader);
   virtual void MakeRecPoints(TTree *clustersTree);
   virtual void StartOfDetectorCycle();
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);
+  virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
   virtual ~AliITSQASPDDataMakerRec();   // dtor
-  Int_t GetOffset(AliQA::TASKINDEX_t task);
-  Int_t GetTaskHisto(AliQA::TASKINDEX_t task);
+  Int_t GetOffset(AliQAv1::TASKINDEX_t task);
+  Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);
 
 private: 
 
index 221cf7f..5b9c287 100644 (file)
@@ -33,7 +33,7 @@
 #include "AliRun.h"
 #include "AliITSQADataMakerSim.h"
 #include "AliITSQASPDDataMakerSim.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliITSdigit.h"   
 #include "AliITSdigitSPD.h"
@@ -92,12 +92,12 @@ void AliITSQASPDDataMakerSim::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliITSQASPDDataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TObjArray* /*list*/)
+void AliITSQASPDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)
 {
   // launch the QA checking
-  AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); 
+  AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n"); 
   
-  //AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
+  //AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);
 }
 
 //____________________________________________________________________________ 
@@ -338,16 +338,16 @@ void AliITSQASPDDataMakerSim::MakeHits(TTree *hits)
 
 //_______________________________________________________________
 
-Int_t AliITSQASPDDataMakerSim::GetOffset(AliQA::TASKINDEX_t task){
+Int_t AliITSQASPDDataMakerSim::GetOffset(AliQAv1::TASKINDEX_t task){
   // Returns histogram offset according to the specified task
   Int_t offset=0;
-  if( task == AliQA::kHITS){
+  if( task == AliQAv1::kHITS){
     offset=fGenOffsetH;
   }
-  else if( task == AliQA::kSDIGITS) {
+  else if( task == AliQAv1::kSDIGITS) {
     offset=fGenOffsetS;
   }
-  else if( task == AliQA::kDIGITS) {
+  else if( task == AliQAv1::kDIGITS) {
     offset=fGenOffsetD;
   }
   else {
@@ -360,16 +360,16 @@ Int_t AliITSQASPDDataMakerSim::GetOffset(AliQA::TASKINDEX_t task){
 
 //_______________________________________________________________
 
-Int_t AliITSQASPDDataMakerSim::GetTaskHisto(AliQA::TASKINDEX_t task) {
+Int_t AliITSQASPDDataMakerSim::GetTaskHisto(AliQAv1::TASKINDEX_t task) {
   // Returns the number of booked histograms for the selected task
   Int_t histotot=0;
-  if( task == AliQA::kHITS) {
+  if( task == AliQAv1::kHITS) {
     histotot=fSPDhHTask ;
   }
-  else if( task == AliQA::kSDIGITS) {
+  else if( task == AliQAv1::kSDIGITS) {
     histotot=fSPDhSTask;
   }
-  else if( task == AliQA::kDIGITS) {
+  else if( task == AliQAv1::kDIGITS) {
     histotot=fSPDhDTask ;
   }
   else {
index 7687909..c783379 100644 (file)
@@ -16,7 +16,7 @@
 
 /* $Id$ */
 
-#include "AliQA.h"
+#include "AliQAv1.h"
 class AliITSQADataMakerSim;
 class TObjArray;
 class TClonesArray;
@@ -29,7 +29,7 @@ public:
   AliITSQASPDDataMakerSim& operator = (const AliITSQASPDDataMakerSim& qac);
 
   virtual void StartOfDetectorCycle();
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);
+  virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
   virtual ~AliITSQASPDDataMakerSim() {;}   // dtor
   virtual void InitDigits();
   virtual void InitSDigits();
@@ -40,8 +40,8 @@ public:
   virtual void MakeDigits(TTree * digits);
   virtual void MakeSDigits(TTree * sdigits);
   virtual void MakeHits(TTree * hits);
-  Int_t GetOffset(AliQA::TASKINDEX_t task);
-  Int_t GetTaskHisto(AliQA::TASKINDEX_t task);
+  Int_t GetOffset(AliQAv1::TASKINDEX_t task);
+  Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);
   //Int_t GetOffsetH() { return fGenOffsetH; }
   //Int_t GetOffsetS() { return fGenOffsetS; }
   //Int_t GetOffsetD() { return fGenOffsetD; }
index a083e51..11df668 100644 (file)
@@ -41,7 +41,7 @@ AliITSQASSDChecker& AliITSQASSDChecker::operator = (const AliITSQASSDChecker& qa
 }
 
 //__________________________________________________________________
-Double_t AliITSQASSDChecker::Check(AliQA::ALITASK_t /*index*/, TObjArray * list) {  
+Double_t AliITSQASSDChecker::Check(AliQAv1::ALITASK_t /*index*/, TObjArray * list) {  
   AliDebug(1,Form("AliITSQASSDChecker called with offset: %d\n", fSubDetOffset));
   
   Double_t test = 0.0  ;
index c4b8906..3bd80b3 100644 (file)
@@ -19,7 +19,7 @@ class TFile ;
 class TH2F ;  
 
 // --- AliRoot header files ---
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQACheckerBase.h"
 #include "AliITSQAChecker.h"
 class AliITSLoader ; 
@@ -30,7 +30,7 @@ public:
   AliITSQASSDChecker():fSubDetOffset(0) {;}          // ctor
   AliITSQASSDChecker& operator = (const AliITSQASSDChecker& qac) ; //operator =
   virtual ~AliITSQASSDChecker() {;} // dtor
-  Double_t Check(AliQA::ALITASK_t /*index*/, TObjArray * /*list*/);
+  Double_t Check(AliQAv1::ALITASK_t /*index*/, TObjArray * /*list*/);
   void SetTaskOffset(Int_t TaskOffset);
 
 
index caf4a57..b553c31 100644 (file)
@@ -34,7 +34,7 @@
 #include "AliITSQASSDDataMakerRec.h"
 #include "AliQADataMakerRec.h"
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliRawReader.h"
 #include "AliRawReaderRoot.h"
@@ -178,13 +178,13 @@ void AliITSQASSDDataMakerRec::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TObjArray* /*list*/)
+void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)
 {
   // launch the QA checking
   if (  fAliITSQADataMakerRec->GetRawsData(0) == NULL ) // Raws not defined
     return ; 
   // launch the QA checking
-  AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); 
+  AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n"); 
   AliInfo(Form("Offset: %d\n",fGenRawsOffset));
   //Data size per DDL
   for(Int_t i = 0; i < fgkNumOfDDLs; i++) {
@@ -280,7 +280,7 @@ void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TO
 
   fSSDEventPerCycle = 0;
   
- // AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
+ // AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);
 }
 
 //____________________________________________________________________________ 
@@ -1244,13 +1244,13 @@ void AliITSQASSDDataMakerRec::MakeRecPoints(TTree *clustersTree)
 }
 
 //____________________________________________________________________________ 
-Int_t AliITSQASSDDataMakerRec::GetOffset(AliQA::TASKINDEX_t task) {
+Int_t AliITSQASSDDataMakerRec::GetOffset(AliQAv1::TASKINDEX_t task) {
   // Returns offset number according to the specified task 
   Int_t offset=0;
-  if( task == AliQA::kRAWS ) {
+  if( task == AliQAv1::kRAWS ) {
     offset=fGenRawsOffset;  
   }
-  else if( task == AliQA::kRECPOINTS ) {
+  else if( task == AliQAv1::kRECPOINTS ) {
     offset=fGenRecPointsOffset;   
   }
   else {
@@ -1261,14 +1261,14 @@ Int_t AliITSQASSDDataMakerRec::GetOffset(AliQA::TASKINDEX_t task) {
 }
 
 //____________________________________________________________________________ 
-Int_t AliITSQASSDDataMakerRec::GetTaskHisto(AliQA::TASKINDEX_t task) {
+Int_t AliITSQASSDDataMakerRec::GetTaskHisto(AliQAv1::TASKINDEX_t task) {
   // Returns the number of histograms associated to the specified task
   Int_t histotot=0;
 
-  if( task == AliQA::kRAWS ) {
+  if( task == AliQAv1::kRAWS ) {
     histotot=fSSDhRawsTask;  
   }
-  else if( task == AliQA::kRECPOINTS ){
+  else if( task == AliQAv1::kRECPOINTS ){
     histotot=fSSDhRecPointsTask;   
   }
   else { 
index 1a83f33..e65d14c 100644 (file)
@@ -13,7 +13,7 @@
 //  W. Ferrarese + P. Cerello Feb 2008
 //  INFN Torino
 
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliITSQADataMakerRec.h"
 #include "AliQADataMakerRec.h"
 
@@ -35,11 +35,11 @@ public:
   virtual void MakeRaws(AliRawReader *rawReader);
   virtual void MakeRecPoints(TTree *clustersTree);
   virtual void StartOfDetectorCycle();
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);
+  virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
   virtual ~AliITSQASSDDataMakerRec(); // dtor
 
-  Int_t GetOffset(AliQA::TASKINDEX_t task);
-  Int_t GetTaskHisto(AliQA::TASKINDEX_t task);
+  Int_t GetOffset(AliQAv1::TASKINDEX_t task);
+  Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);
 
  private:
 
index f7a810b..93b0f68 100644 (file)
@@ -41,7 +41,7 @@
 #include "AliITSQADataMakerSim.h"
 #include "AliITSQASSDDataMakerSim.h"
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliRawReader.h"
 
@@ -94,11 +94,11 @@ void AliITSQASSDDataMakerSim::StartOfDetectorCycle() {
 }
 
 //____________________________________________________________________________ 
-void AliITSQASSDDataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TObjArray* /*list*/) {
+void AliITSQASSDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/) {
   // launch the QA checking
-  AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); 
+  AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n"); 
   
-//  AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
+//  AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);
 }
 
 //____________________________________________________________________________ 
@@ -289,16 +289,16 @@ void AliITSQASSDDataMakerSim::MakeHits(TTree *hits) {
 
 
 //____________________________________________________________________________ 
-Int_t AliITSQASSDDataMakerSim::GetOffset(AliQA::TASKINDEX_t task){
+Int_t AliITSQASSDDataMakerSim::GetOffset(AliQAv1::TASKINDEX_t task){
   // Returns histogram offset according to the specified task
   Int_t offset=0;
-  if( task == AliQA::kHITS){
+  if( task == AliQAv1::kHITS){
     offset=fGenOffsetH;  
   }
-  else if( task == AliQA::kSDIGITS) {
+  else if( task == AliQAv1::kSDIGITS) {
     offset=fGenOffsetS;   
   }
-  else if( task == AliQA::kDIGITS) {
+  else if( task == AliQAv1::kDIGITS) {
     offset=fGenOffsetD;   
   }
   else {
@@ -310,16 +310,16 @@ Int_t AliITSQASSDDataMakerSim::GetOffset(AliQA::TASKINDEX_t task){
 
 
 //____________________________________________________________________________ 
-Int_t AliITSQASSDDataMakerSim::GetTaskHisto(AliQA::TASKINDEX_t task) {
+Int_t AliITSQASSDDataMakerSim::GetTaskHisto(AliQAv1::TASKINDEX_t task) {
   // Returns the number of booked histograms for the selected task
   Int_t histotot=0;
-  if( task == AliQA::kHITS) {
+  if( task == AliQAv1::kHITS) {
     histotot=fSSDhHTask ;  
   }
-  else if( task == AliQA::kSDIGITS) {
+  else if( task == AliQAv1::kSDIGITS) {
     histotot=fSSDhSTask;   
   }
-  else if( task == AliQA::kDIGITS) {
+  else if( task == AliQAv1::kDIGITS) {
     histotot=fSSDhDTask ;   
   }
   else {
index 257aaf1..42e389e 100644 (file)
@@ -14,7 +14,7 @@
 //  W. Ferrarese + P. Cerello Feb 2008
 //  SSD QA part: P. Christakoglou
 
-#include "AliQA.h"
+#include "AliQAv1.h"
 class AliITSQADataMakerSim;
 class TObjArray;
 class TClonesArray;
@@ -27,7 +27,7 @@ public:
   AliITSQASSDDataMakerSim& operator = (const AliITSQASSDDataMakerSim& qac);
 
   virtual void StartOfDetectorCycle();
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);
+  virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
   virtual ~AliITSQASSDDataMakerSim() {;}   // dtor
   virtual void InitDigits();
   virtual void InitSDigits();
@@ -38,8 +38,8 @@ public:
   virtual void MakeDigits(TTree * digits);
   virtual void MakeSDigits(TTree * sdigits);
   virtual void MakeHits(TTree * hits);
-  Int_t GetOffset(AliQA::TASKINDEX_t task);
-  Int_t GetTaskHisto(AliQA::TASKINDEX_t task);
+  Int_t GetOffset(AliQAv1::TASKINDEX_t task);
+  Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);
 
 private:
 
index accac67..6e038b2 100644 (file)
@@ -26,7 +26,7 @@
 
 #include "AliMUONPadStatusMaker.h"
 
-#include "AliQA.h"
+#include "AliQAv1.h"
 
 #include "AliMUON2DMap.h"
 #include "AliMUON2DStoreValidator.h"
@@ -87,7 +87,7 @@ fTrackerData(0x0)
                   fPedestals->ClassName(),
                   fGains->ClassName()));
   
-  TString qaFileName(AliQA::GetQADataFileName("MUON",calibData.RunNumber()));
+  TString qaFileName(AliQAv1::GetQADataFileName("MUON",calibData.RunNumber()));
   
   // search the QA file in memory first.
   TFile* f = static_cast<TFile*>(gROOT->GetListOfFiles()->FindObject(qaFileName.Data()));
index 51243c6..d694a65 100644 (file)
@@ -32,7 +32,7 @@
 #include "AliLog.h"
 #include "AliMUONVTrackerData.h"
 #include "AliMpManuIterator.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include <TDirectory.h>
 #include <TH1.h>
 
@@ -62,7 +62,7 @@ AliMUONQAChecker::AliMUONQAChecker(const AliMUONQAChecker& qac) :
 
 //______________________________________________________________________________
 Double_t *
-AliMUONQAChecker::Check(AliQA::ALITASK_t /*index*/)
+AliMUONQAChecker::Check(AliQAv1::ALITASK_t /*index*/)
 {
   /// Check data
   
@@ -73,21 +73,21 @@ AliMUONQAChecker::Check(AliQA::ALITASK_t /*index*/)
 
 //______________________________________________________________________________
 Double_t *
-AliMUONQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
+AliMUONQAChecker::Check(AliQAv1::ALITASK_t index, TObjArray ** list)
 {
   /// Check objects in list
   
-  if ( index == AliQA::kRAW ) 
+  if ( index == AliQAv1::kRAW ) 
   {
     return CheckRaws(list);
   }
   
-  if ( index == AliQA::kREC)
+  if ( index == AliQAv1::kREC)
   {
     return CheckRecPoints(list);
   }
   
-  if ( index == AliQA::kESD )
+  if ( index == AliQAv1::kESD )
   {
     return CheckESD(list);
   }
@@ -138,7 +138,7 @@ AliMUONQAChecker::MarkHisto(TH1& histo, Double_t value) const
   
   if ( value != 1.0 )
   {
-    histo.SetBit(AliQA::GetQABit());
+    histo.SetBit(AliQAv1::GetQABit());
   }
   
   return value;
@@ -239,48 +239,48 @@ AliMUONQAChecker::CheckRaws(TObjArray ** list)
 }
 
 //______________________________________________________________________________
-void AliMUONQAChecker::Init(const AliQA::DETECTORINDEX_t det) 
+void AliMUONQAChecker::Init(const AliQAv1::DETECTORINDEX_t det) 
 {
   // intialises QA and QA checker settings
-  AliQA::Instance(det) ; 
-  Float_t hiValue[AliQA::kNBIT] ; 
-  Float_t lowValue[AliQA::kNBIT] ;
-  lowValue[AliQA::kINFO]      = 0.999   ; 
-  hiValue[AliQA::kINFO]       = 1.0 ; 
-  hiValue[AliQA::kWARNING]    = 0.99 ; 
-  lowValue[AliQA::kWARNING]   = 0.5 ; 
-  lowValue[AliQA::kERROR]     = 0.0   ; 
-  hiValue[AliQA::kERROR]      = 0.5 ; 
-  lowValue[AliQA::kFATAL]     = -1.0   ; 
-  hiValue[AliQA::kFATAL]      = 0.0 ; 
+  AliQAv1::Instance(det) ; 
+  Float_t hiValue[AliQAv1::kNBIT] ; 
+  Float_t lowValue[AliQAv1::kNBIT] ;
+  lowValue[AliQAv1::kINFO]      = 0.999   ; 
+  hiValue[AliQAv1::kINFO]       = 1.0 ; 
+  hiValue[AliQAv1::kWARNING]    = 0.99 ; 
+  lowValue[AliQAv1::kWARNING]   = 0.5 ; 
+  lowValue[AliQAv1::kERROR]     = 0.0   ; 
+  hiValue[AliQAv1::kERROR]      = 0.5 ; 
+  lowValue[AliQAv1::kFATAL]     = -1.0   ; 
+  hiValue[AliQAv1::kFATAL]      = 0.0 ; 
   SetHiLo(&hiValue[0], &lowValue[0]) ; 
 }
 
 //______________________________________________________________________________
 void 
-AliMUONQAChecker::SetQA(AliQA::ALITASK_t index, Double_t * value) const
+AliMUONQAChecker::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
 {
   /// sets the QA according the return value of the Check
 
-  AliQA * qa = AliQA::Instance(index);
+  AliQAv1 * qa = AliQAv1::Instance(index);
   
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
-    qa->UnSet(AliQA::kFATAL, specie);
-    qa->UnSet(AliQA::kWARNING, specie);
-    qa->UnSet(AliQA::kERROR, specie);
-    qa->UnSet(AliQA::kINFO, specie);
+    qa->UnSet(AliQAv1::kFATAL, specie);
+    qa->UnSet(AliQAv1::kWARNING, specie);
+    qa->UnSet(AliQAv1::kERROR, specie);
+    qa->UnSet(AliQAv1::kINFO, specie);
 
     if ( ! value ) { // No checker is implemented, set all QA to Fatal
-      qa->Set(AliQA::kFATAL, specie) ; 
+      qa->Set(AliQAv1::kFATAL, specie) ; 
     } else {
-      if ( value[specie] >= fLowTestValue[AliQA::kFATAL] && value[specie] < fUpTestValue[AliQA::kFATAL] ) 
-        qa->Set(AliQA::kFATAL, specie) ; 
-      else if ( value[specie] > fLowTestValue[AliQA::kERROR] && value[specie] <= fUpTestValue[AliQA::kERROR]  )
-        qa->Set(AliQA::kERROR, specie) ; 
-      else if ( value[specie] > fLowTestValue[AliQA::kWARNING] && value[specie] <= fUpTestValue[AliQA::kWARNING]  )
-        qa->Set(AliQA::kWARNING, specie) ;
-      else if ( value[specie] > fLowTestValue[AliQA::kINFO] && value[specie] <= fUpTestValue[AliQA::kINFO] ) 
-        qa->Set(AliQA::kINFO, specie) ;        
+      if ( value[specie] >= fLowTestValue[AliQAv1::kFATAL] && value[specie] < fUpTestValue[AliQAv1::kFATAL] ) 
+        qa->Set(AliQAv1::kFATAL, specie) ; 
+      else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] && value[specie] <= fUpTestValue[AliQAv1::kERROR]  )
+        qa->Set(AliQAv1::kERROR, specie) ; 
+      else if ( value[specie] > fLowTestValue[AliQAv1::kWARNING] && value[specie] <= fUpTestValue[AliQAv1::kWARNING]  )
+        qa->Set(AliQAv1::kWARNING, specie) ;
+      else if ( value[specie] > fLowTestValue[AliQAv1::kINFO] && value[specie] <= fUpTestValue[AliQAv1::kINFO] ) 
+        qa->Set(AliQAv1::kINFO, specie) ;      
     }
   }
 }
index 5859243..2c6a07b 100644 (file)
@@ -24,15 +24,15 @@ public:
   AliMUONQAChecker(const AliMUONQAChecker& qac);
   virtual ~AliMUONQAChecker();
 
-  virtual void   Init(const AliQA::DETECTORINDEX_t det) ; 
+  virtual void   Init(const AliQAv1::DETECTORINDEX_t det) ; 
 
 protected:
 
   using AliQACheckerBase::Check;
   
-  virtual Double_t * Check(AliQA::ALITASK_t index) ;
-  virtual Double_t * Check(AliQA::ALITASK_t index, TObjArray ** list) ;
-  virtual void SetQA(AliQA::ALITASK_t index, Double_t * value) const ; 
+  virtual Double_t * Check(AliQAv1::ALITASK_t index) ;
+  virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** list) ;
+  virtual void SetQA(AliQAv1::ALITASK_t index, Double_t * value) const ;       
        
   Double_t * CheckRaws(TObjArray** list);
   Double_t * CheckRecPoints(TObjArray** list);
index 5b9cec4..b343c9f 100644 (file)
@@ -87,7 +87,7 @@ ClassImp(AliMUONQADataMakerRec)
            
 //____________________________________________________________________________ 
 AliMUONQADataMakerRec::AliMUONQADataMakerRec() : 
-AliQADataMakerRec(AliQA::GetDetName(AliQA::kMUON), "MUON Quality Assurance Data Maker"),
+AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kMUON), "MUON Quality Assurance Data Maker"),
 fIsInitRaws(kFALSE),
 fIsInitRecPointsTracker(kFALSE),
 fIsInitRecPointsTrigger(kFALSE),
@@ -173,7 +173,7 @@ AliMUONQADataMakerRec::~AliMUONQADataMakerRec()
 }
 
 //____________________________________________________________________________ 
-void AliMUONQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray** list)
+void AliMUONQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list)
 {
   ///Detector specific actions at end of cycle
   
@@ -184,7 +184,7 @@ void AliMUONQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArra
   
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
     SetEventSpecie(specie) ; 
-    if ( task == AliQA::kRAWS && fTrackerDataMaker ) 
+    if ( task == AliQAv1::kRAWS && fTrackerDataMaker ) 
       {
         TIter next(list[specie]);
         TObject* o;
@@ -218,7 +218,7 @@ void AliMUONQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArra
       }
     
     // Normalize RecPoints histos
-    if ( task == AliQA::kRECPOINTS ) {
+    if ( task == AliQAv1::kRECPOINTS ) {
       
       TH1* hTrackerClusterChargePerChMean = GetRecPointsData(kTrackerClusterChargePerChMean);
       TH1* hTrackerClusterChargePerChSigma = GetRecPointsData(kTrackerClusterChargePerChSigma);
@@ -271,7 +271,7 @@ void AliMUONQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArra
     }
     
     // Normalize ESD histos
-    if ( task == AliQA::kESDS ) {
+    if ( task == AliQAv1::kESDS ) {
       
       Double_t nTracks = GetESDsData(kESDnClustersPerTrack)->GetEntries();
       if (nTracks <= 0) continue;
@@ -431,7 +431,7 @@ void AliMUONQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArra
   }
   
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kMUON, task, list) ;
+  AliQAChecker::Instance()->Run(AliQAv1::kMUON, task, list) ;
 }
 
 //____________________________________________________________________________ 
@@ -1226,14 +1226,14 @@ void AliMUONQADataMakerRec::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliMUONQADataMakerRec::DisplayTriggerInfo(AliQA::TASKINDEX_t task)
+void AliMUONQADataMakerRec::DisplayTriggerInfo(AliQAv1::TASKINDEX_t task)
 {
   //
   /// Display trigger information in a user-friendly way:
   /// from local board and strip numbers to their position on chambers
   //
 
-  if(task!=AliQA::kRECPOINTS && task!=AliQA::kRAWS) return;
+  if(task!=AliQAv1::kRECPOINTS && task!=AliQAv1::kRAWS) return;
 
   AliMUONTriggerDisplay triggerDisplay;
   
@@ -1242,12 +1242,12 @@ void AliMUONQADataMakerRec::DisplayTriggerInfo(AliQA::TASKINDEX_t task)
 
   for (Int_t iCath = 0; iCath < AliMpConstants::NofCathodes(); iCath++)
   {
-    if(task==AliQA::kRECPOINTS){
+    if(task==AliQAv1::kRECPOINTS){
       ERecPoints hindex 
        = ( iCath == 0 ) ? kTriggerDigitsBendPlane : kTriggerDigitsNonBendPlane;
       histoStrips = (TH3F*)GetRecPointsData(hindex);
     }
-    else if(task==AliQA::kRAWS){
+    else if(task==AliQAv1::kRAWS){
       ERaw hindex 
        = ( iCath == 0 ) ? kTriggerScalersBP : kTriggerScalersNBP;
       histoStrips = (TH3F*)GetRawsData(hindex);
@@ -1256,24 +1256,24 @@ void AliMUONQADataMakerRec::DisplayTriggerInfo(AliQA::TASKINDEX_t task)
     
     for (Int_t iChamber = 0; iChamber < AliMpConstants::NofTriggerChambers(); iChamber++)
     {
-      if(task==AliQA::kRECPOINTS){
+      if(task==AliQAv1::kRECPOINTS){
        histoDisplayStrips = (TH2F*)GetRecPointsData(kTriggerDigitsDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
       }
-      else if(task==AliQA::kRAWS){
+      else if(task==AliQAv1::kRAWS){
        histoDisplayStrips = (TH2F*)GetRawsData(kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
       }
       Int_t bin = histoStrips->GetXaxis()->FindBin(11+iChamber);
       histoStrips->GetXaxis()->SetRange(bin,bin);
       TH2F* inputHisto = (TH2F*)histoStrips->Project3D("zy");
       triggerDisplay.FillDisplayHistogram(inputHisto, histoDisplayStrips, AliMUONTriggerDisplay::kDisplayStrips, iCath, iChamber);
-      if(task==AliQA::kRAWS) {
+      if(task==AliQAv1::kRAWS) {
         Float_t acquisitionTime = ((TH1F*)GetRawsData(kTriggerScalersTime))->GetBinContent(1);
         histoDisplayStrips->Scale(1./acquisitionTime);
       }
     } // iChamber
   } // iCath
 
-  if(task==AliQA::kRAWS){    
+  if(task==AliQAv1::kRAWS){    
     TH2F* histoI  = (TH2F*) GetRawsData(kTriggerRPCi);
     TH2F* histoHV = (TH2F*) GetRawsData(kTriggerRPChv);
     FillTriggerDCSHistos();
@@ -1287,7 +1287,7 @@ void AliMUONQADataMakerRec::DisplayTriggerInfo(AliQA::TASKINDEX_t task)
     }
   }
 
-  if(task==AliQA::kRECPOINTS){
+  if(task==AliQAv1::kRECPOINTS){
     TH1F* histoBoards = (TH1F*)GetRecPointsData(kTriggeredBoards);
     TH2F* histoDisplayBoards = (TH2F*)GetRecPointsData(kTriggerBoardsDisplay);
     triggerDisplay.FillDisplayHistogram(histoBoards, histoDisplayBoards, AliMUONTriggerDisplay::kDisplayBoards, 0, 0);
index 87881ef..29407d9 100644 (file)
@@ -43,9 +43,9 @@ protected:
   virtual void MakeRecPoints(TTree* recpo); 
   virtual void MakeESDs(AliESDEvent* esd) ;
   
-  virtual void DefaultEndOfDetectorCycle(AliQA::TASKINDEX_t) {}
+  virtual void DefaultEndOfDetectorCycle(AliQAv1::TASKINDEX_t) {}
 
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray** list);
+  virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list);
 
 private:
   /// Raw histograms indices
@@ -144,7 +144,7 @@ private:
 private:
        
   void Ctor();
-  void DisplayTriggerInfo(AliQA::TASKINDEX_t task);
+  void DisplayTriggerInfo(AliQAv1::TASKINDEX_t task);
   Bool_t FillTriggerDCSHistos();
   void InitRecPointsTracker();
   void InitRecPointsTrigger();
index 3205048..fb859cc 100644 (file)
@@ -46,7 +46,7 @@ ClassImp(AliMUONQADataMakerSim)
            
 //____________________________________________________________________________ 
 AliMUONQADataMakerSim::AliMUONQADataMakerSim() : 
-    AliQADataMakerSim(AliQA::GetDetName(AliQA::kMUON), "MUON Quality Assurance Data Maker"),
+    AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kMUON), "MUON Quality Assurance Data Maker"),
     fHitStore(0x0),
     fDigitStore(0x0)   
 {
@@ -199,11 +199,11 @@ void AliMUONQADataMakerSim::MakeDigits(TTree* digitsTree)
 }
       
 //____________________________________________________________________________ 
-void AliMUONQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray** list)
+void AliMUONQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list)
 {
     ///Detector specific actions at end of cycle
     // do the QA checking
-    AliQAChecker::Instance()->Run(AliQA::kMUON, task, list) ;  
+    AliQAChecker::Instance()->Run(AliQAv1::kMUON, task, list) ;  
 }
 
 
index 53079a8..eafdcad 100644 (file)
@@ -50,7 +50,7 @@ private:
       /// make SDigits QA from Tree
   virtual void   MakeDigits(TTree* digitsTree);
   
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray** list);
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list);
 
   AliMUONVHitStore*   fHitStore;   //!< pointer to hit store
   AliMUONVDigitStore* fDigitStore; //!< pointer to digit store
index dc2471e..dcd4cb1 100644 (file)
     class AliGRPObject {};
 
     class AliQA {};
+    class AliQAv1 {};
 
     class AliRunInfo {};
     class AliEventInfo {};
index 15455fd..d413462 100644 (file)
@@ -51,7 +51,7 @@ void runReconstruction(int seed, const char* input, const char* recoptions)
   MuonRec->SetNumberOfEventsPerFile(1000);
   MuonRec->SetOption("MUON",recoptions);
   MuonRec->SetRunQA("MUON:ALL");
-  MuonRec->SetQAWriteExpert(AliQA::kMUON);
+  MuonRec->SetQAWriteExpert(AliQAv1::kMUON);
   // uncomment the following lines if you want to set custom RecoParam
   // instead of getting them from the OCDB
   //  AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
index 8332deb..10e9b03 100644 (file)
@@ -34,7 +34,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliPHOSQAChecker.h"
 
index ed9ecef..9b5057c 100644 (file)
@@ -51,7 +51,7 @@ ClassImp(AliPHOSQADataMakerRec)
            
 //____________________________________________________________________________ 
   AliPHOSQADataMakerRec::AliPHOSQADataMakerRec() : 
-  AliQADataMakerRec(AliQA::GetDetName(AliQA::kPHOS), "PHOS Quality Assurance Data Maker")
+  AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kPHOS), "PHOS Quality Assurance Data Maker")
 {
   // ctor
 }
@@ -75,7 +75,7 @@ AliPHOSQADataMakerRec& AliPHOSQADataMakerRec::operator = (const AliPHOSQADataMak
 }
  
 //____________________________________________________________________________ 
-void AliPHOSQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliPHOSQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   if(GetRawsData(kHGqualMod1) && GetRawsData(kHGmod1))
@@ -89,7 +89,7 @@ void AliPHOSQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArra
   if(GetRawsData(kHGqualMod5) && GetRawsData(kHGmod5))
     GetRawsData(kHGqualMod5)->Divide( GetRawsData(kHGmod5) ) ;
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kPHOS, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kPHOS, task, list) ;  
 }
 
 //____________________________________________________________________________ 
@@ -445,16 +445,16 @@ void AliPHOSQADataMakerRec::MakeRaws(AliRawReader* rawReader)
   }                    
   delete decoder;
   GetRawsData(kEtotLG)->Fill(lgEtot) ; 
-  TParameter<double> * p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kEtotLG)->GetName()))) ; 
+  TParameter<double> * p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kEtotLG)->GetName()))) ; 
   p->SetVal(lgEtot) ; 
   GetRawsData(kEtotHG)->Fill(hgEtot) ;  
-  p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kEtotHG)->GetName()))) ; 
+  p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kEtotHG)->GetName()))) ; 
   p->SetVal(hgEtot) ; 
   GetRawsData(kNtotLG)->Fill(lgNtot) ;
-  p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kNtotLG)->GetName()))) ; 
+  p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kNtotLG)->GetName()))) ; 
   p->SetVal(lgNtot) ; 
   GetRawsData(kNtotHG)->Fill(hgNtot) ;
-  p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kNtotHG)->GetName()))) ; 
+  p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kNtotHG)->GetName()))) ; 
   p->SetVal(hgNtot) ; 
 }
 //____________________________________________________________________________
index 12d937b..5401af1 100644 (file)
@@ -54,7 +54,7 @@ public:
 private:
   const AliPHOSRecoParam* GetRecoParam() const { return dynamic_cast<const AliPHOSRecoParam *>(fRecoParam); }
 
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
   virtual void   InitESDs() ; 
   virtual void   InitRecPoints() ; 
   virtual void   InitRaws() ; 
index 613df77..963bae7 100644 (file)
@@ -44,7 +44,7 @@ ClassImp(AliPHOSQADataMakerSim)
            
 //____________________________________________________________________________ 
 AliPHOSQADataMakerSim::AliPHOSQADataMakerSim() : 
-  AliQADataMakerSim(AliQA::GetDetName(AliQA::kPHOS), "PHOS Quality Assurance Data Maker"),
+  AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kPHOS), "PHOS Quality Assurance Data Maker"),
   fHits(0x0)
 {
   // ctor
@@ -72,11 +72,11 @@ AliPHOSQADataMakerSim& AliPHOSQADataMakerSim::operator = (const AliPHOSQADataMak
 }
  
 //____________________________________________________________________________ 
-void AliPHOSQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliPHOSQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kPHOS, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kPHOS, task, list) ;  
 }
 
 //____________________________________________________________________________ 
index 854a9eb..ffe05d6 100644 (file)
@@ -36,7 +36,7 @@ public:
   virtual ~AliPHOSQADataMakerSim() {;} // dtor
   
 private:
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
   virtual void   InitHits() ; 
   virtual void   InitDigits() ; 
   virtual void   InitSDigits() ; 
index e5bbb10..78fe69d 100644 (file)
@@ -202,14 +202,14 @@ void AliPHOSSDigitizer::Exec(Option_t *option)
   
 /*
        // check the QA result for RAWS
-  AliQA * qa = AliQA::Instance(AliQA::kPHOS) ; 
-  if ( qa->IsSet(AliQA::kPHOS, AliQA::kRAW, AliQA::kFATAL)) {
+  AliQAv1 * qa = AliQAv1::Instance(AliQAv1::kPHOS) ; 
+  if ( qa->IsSet(AliQAv1::kPHOS, AliQAv1::kRAW, AliQAv1::kFATAL)) {
        AliFatal("QA status in RAW was Fatal") ;
-  } else if ( qa->IsSet(AliQA::kPHOS, AliQA::kRAW, AliQA::kERROR)) {
+  } else if ( qa->IsSet(AliQAv1::kPHOS, AliQAv1::kRAW, AliQAv1::kERROR)) {
        AliError("QA status in RAW was Error") ;
-  } else if ( qa->IsSet(AliQA::kPHOS, AliQA::kRAW, AliQA::kWARNING) ) {
+  } else if ( qa->IsSet(AliQAv1::kPHOS, AliQAv1::kRAW, AliQAv1::kWARNING) ) {
        AliWarning("QA status in RAW was Warning") ;
-  } else if ( qa->IsSet(AliQA::kPHOS, AliQA::kRAW, AliQA::kINFO) ) {
+  } else if ( qa->IsSet(AliQAv1::kPHOS, AliQAv1::kRAW, AliQAv1::kINFO) ) {
        AliInfo("QA status in RAW was Info") ;
   }
 */
@@ -280,13 +280,13 @@ void AliPHOSSDigitizer::Exec(Option_t *option)
 //    // make Quality Assurance data
 //
 //    if (GetQADataMaker()->IsCycleDone() ) {
-//      GetQADataMaker()->EndOfCycle(AliQA::kHITS) ; 
-//       GetQADataMaker()->EndOfCycle(AliQA::kSDIGITS) ; 
-//      GetQADataMaker()->StartOfCycle(AliQA::kHITS) ; 
-//       GetQADataMaker()->StartOfCycle(AliQA::kSDIGITS, kTRUE) ; 
+//      GetQADataMaker()->EndOfCycle(AliQAv1::kHITS) ; 
+//       GetQADataMaker()->EndOfCycle(AliQAv1::kSDIGITS) ; 
+//      GetQADataMaker()->StartOfCycle(AliQAv1::kHITS) ; 
+//       GetQADataMaker()->StartOfCycle(AliQAv1::kSDIGITS, kTRUE) ; 
 //   }
-//    GetQADataMaker()->Exec(AliQA::kHITS, hits) ; 
-//    GetQADataMaker()->Exec(AliQA::kSDIGITS, sdigits) ; 
+//    GetQADataMaker()->Exec(AliQAv1::kHITS, hits) ; 
+//    GetQADataMaker()->Exec(AliQAv1::kSDIGITS, sdigits) ; 
 //    GetQADataMaker()->Increment() ;
        
     //Now write SDigits
@@ -307,8 +307,8 @@ void AliPHOSSDigitizer::Exec(Option_t *option)
   }// event loop
   
 //  //Write the quality assurance data 
-//  GetQADataMaker()->EndOfCycle(AliQA::kHITS) ;    
-//  GetQADataMaker()->EndOfCycle(AliQA::kSDIGITS) ;    
+//  GetQADataMaker()->EndOfCycle(AliQAv1::kHITS) ;    
+//  GetQADataMaker()->EndOfCycle(AliQAv1::kSDIGITS) ;    
 //  GetQADataMaker()->Finish() ;
 
   Unload();
index f2eb59c..548de49 100644 (file)
@@ -31,7 +31,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliPMDQAChecker.h"
 
index 7cedd07..0fbdf94 100644 (file)
@@ -46,7 +46,7 @@ ClassImp(AliPMDQADataMakerRec)
            
 //____________________________________________________________________________ 
   AliPMDQADataMakerRec::AliPMDQADataMakerRec() : 
-  AliQADataMakerRec(AliQA::GetDetName(AliQA::kPMD), "PMD Quality Assurance Data Maker")
+  AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kPMD), "PMD Quality Assurance Data Maker")
 {
   // ctor
 }
@@ -580,9 +580,9 @@ void AliPMDQADataMakerRec::StartOfDetectorCycle()
   
 }
 //____________________________________________________________________________ 
-void AliPMDQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliPMDQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kPMD, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kPMD, task, list) ;  
 }
index aae8b3b..4bbe074 100644 (file)
@@ -38,7 +38,7 @@ class AliPMDQADataMakerRec: public AliQADataMakerRec {
     virtual void   MakeRecPoints(TTree * recpoTree) ; 
     virtual void   MakeESDs(AliESDEvent * esd) ;
     virtual void   StartOfDetectorCycle() ; 
-    virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+    virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
     
     ClassDef(AliPMDQADataMakerRec,1)  // description 
 
index ab08b03..81c1918 100644 (file)
@@ -43,7 +43,7 @@ ClassImp(AliPMDQADataMakerSim)
            
 //____________________________________________________________________________ 
 AliPMDQADataMakerSim::AliPMDQADataMakerSim() : 
-    AliQADataMakerSim(AliQA::GetDetName(AliQA::kPMD), "PMD Quality Assurance Data Maker")
+    AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kPMD), "PMD Quality Assurance Data Maker")
 {
     // ctor
 }
@@ -333,9 +333,9 @@ void AliPMDQADataMakerSim::StartOfDetectorCycle()
 }
 //____________________________________________________________________________ 
 
-void AliPMDQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliPMDQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
     //Detector specific actions at end of cycle
     // do the QA checking
-    AliQAChecker::Instance()->Run(AliQA::kPMD, task, list) ;  
+    AliQAChecker::Instance()->Run(AliQAv1::kPMD, task, list) ;  
 }
index 2734007..03ce0de 100644 (file)
@@ -41,7 +41,7 @@ private:
   virtual void   MakeDigits(TClonesArray * digits) ; 
   virtual void   MakeDigits(TTree * digitTree) ; 
   virtual void   StartOfDetectorCycle() ; 
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
 
 
   ClassDef(AliPMDQADataMakerSim,1)  // description 
index dda4f9f..68a82dc 100644 (file)
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliCorrQAChecker.h"
 
 ClassImp(AliCorrQAChecker)
 
 //__________________________________________________________________
-Double_t * AliCorrQAChecker::Check(AliQA::ALITASK_t index, TNtupleD ** nData) 
+Double_t * AliCorrQAChecker::Check(AliQAv1::ALITASK_t index, TNtupleD ** nData) 
 {
  // check the QA of correlated data stored in a ntuple
   
@@ -50,7 +50,7 @@ Double_t * AliCorrQAChecker::Check(AliQA::ALITASK_t index, TNtupleD ** nData)
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
     test[specie] = 0. ; 
     
-  if ( index != AliQA::kRAW ) {
+  if ( index != AliQAv1::kRAW ) {
     AliWarning("Checker not implemented") ; 
     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
       test[specie] = 1. ; 
index d1cb14f..553e000 100644 (file)
@@ -31,9 +31,9 @@ public:
   AliCorrQAChecker(const AliCorrQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()) {;} // cpy ctor   
   virtual ~AliCorrQAChecker() {;} // dtor
 
-  virtual Double_t *  Check(AliQA::ALITASK_t index) { return AliQACheckerBase::Check(index) ;}
-  virtual Double_t * Check(AliQA::ALITASK_t index, TObjArray ** obj) { return AliQACheckerBase::Check(index, obj) ;}
-  Double_t * Check(AliQA::ALITASK_t index, TNtupleD ** nData) ; 
+  virtual Double_t *  Check(AliQAv1::ALITASK_t index) { return AliQACheckerBase::Check(index) ;}
+  virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** obj) { return AliQACheckerBase::Check(index, obj) ;}
+  Double_t * Check(AliQAv1::ALITASK_t index, TNtupleD ** nData) ; 
 
 private:
   
index e3c46e6..ca06531 100644 (file)
@@ -43,7 +43,7 @@ ClassImp(AliCorrQADataMakerRec)
            
 //____________________________________________________________________________ 
 AliCorrQADataMakerRec::AliCorrQADataMakerRec(AliQADataMaker ** qadm ) : 
-AliQADataMakerRec(AliQA::GetDetName(AliQA::kCORR), "Corr Quality Assurance Data Maker"),
+AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kCORR), "Corr Quality Assurance Data Maker"),
   fMaxRawVar(0),  
   fqadm(qadm)
 {
@@ -87,12 +87,12 @@ AliCorrQADataMakerRec::~AliCorrQADataMakerRec()
 }
   
 //____________________________________________________________________________ 
-void AliCorrQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** /*list*/)
+void AliCorrQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** /*list*/)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  if (task == AliQA::kRAWS) {
-     AliQAChecker::Instance()->Run(AliQA::kCORR, task, fCorrNt) ; 
+  if (task == AliQAv1::kRAWS) {
+     AliQAChecker::Instance()->Run(AliQAv1::kCORR, task, fCorrNt) ; 
   }
 }
 
@@ -121,7 +121,7 @@ void AliCorrQADataMakerRec::InitRaws()
   delete fRawsQAList ; // not needed for the time being 
   fRawsQAList = NULL ; 
   TString varlist("") ;
-  for ( Int_t detIndex = 0 ; detIndex < AliQA::kNDET ; detIndex++ ) {
+  for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++ ) {
     AliQADataMaker * qadm = fqadm[detIndex] ; 
     if ( ! qadm ) 
       continue ;
@@ -141,7 +141,7 @@ void AliCorrQADataMakerRec::InitRaws()
     AliWarning("NTUPLE not created") ; 
   } else {
     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
-      char * name = Form("%s_%s", AliQA::GetQACorrName(), AliRecoParam::GetEventSpecieName(specie)) ; 
+      char * name = Form("%s_%s", AliQAv1::GetQACorrName(), AliRecoParam::GetEventSpecieName(specie)) ; 
       fCorrNt[specie] = new TNtupleD(name, "Raws data correlation among detectors", varlist.Data()) ;  
     }
   }  
@@ -164,7 +164,7 @@ void AliCorrQADataMakerRec::MakeRaws(AliRawReader *)
     const Int_t kSize = fMaxRawVar ; 
     Double_t  *varvalue = new Double_t[kSize] ;
     Int_t index = 0 ;
-    for ( Int_t detIndex = 0 ; detIndex < AliQA::kNDET ; detIndex++ ) {
+    for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++ ) {
       AliQADataMaker * qadm = fqadm[detIndex] ; 
       if ( ! qadm ) 
         continue ;
index 69349eb..f1d6855 100644 (file)
@@ -33,7 +33,7 @@ public:
   
 private:
 
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
   virtual void   InitESDs() ; 
   virtual void   InitRecPoints() ; 
   virtual void   InitRaws() ; 
index 03df1ac..107e8cb 100644 (file)
@@ -34,7 +34,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliGlobalQAChecker.h"
 
index 3aed4c0..6b808f2 100644 (file)
 ClassImp(AliGlobalQADataMaker)
  
 //____________________________________________________________________________ 
-void AliGlobalQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliGlobalQADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kGLOBAL, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kGLOBAL, task, list) ;  
 }
 
 //____________________________________________________________________________ 
index ef8478c..99e615d 100644 (file)
@@ -28,7 +28,7 @@ public:
        AliQADataMakerRec(qadm) {;}
 
 private:
-       void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+       void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
 
        void InitRaws(); 
        void InitRecPoints();
index 47365f1..c24360d 100644 (file)
@@ -48,7 +48,7 @@
 ClassImp(AliQA)
 AliQA    * AliQA::fgQA                   = 0x0 ;
 TFile    * AliQA::fgQADataFile           = 0x0 ;   
-TString    AliQA::fgQADataFileName       = "QA" ;  // will transform into Det.QA.run.root  
+TString    AliQA::fgQADataFileName       = "QA" ;  // will transform into Det.QA.run.cycle.root  
 TFile    * AliQA::fgQARefFile            = 0x0 ;   
 TString    AliQA::fgQARefDirName              = "" ; 
 TString    AliQA::fgQARefFileName        = "QA.root" ;
@@ -58,137 +58,106 @@ TString    AliQA::fgQAResultFileName     = "QA.root" ;
 TString    AliQA::fgDetNames[]           = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD",
                                             "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT", "Global", "CORR"} ;   
 TString    AliQA::fgGRPPath              = "GRP/GRP/Data" ; 
+TString    AliQA::fgRTNames[]            = {"UNKNOWN", "AUTO_TEST", "CALIBRATION", "CALIBRATION_PULSER", "CHANNEL_DELAY_TUNING", "COSMIC", 
+                                                                                                                                                                               "COSMICS", "DAQ_FO_UNIF_SCAN", "DAQ_GEN_DAC_SCAN", "DAQ_MEAN_TH_SCAN", "DAQ_MIN_TH_SCAN", 
+                                                                                                                                                                               "DAQ_NOISY_PIX_SCAN", "DAQ_PIX_DELAY_SCAN", "DAQ_UNIFORMITY_SCAN", "DCS_FO_UNIF_SCAN", 
+                                                                                                                                                                               "DCS_MEAN_TH_SCAN", "DCS_MIN_TH_SCAN", "DCS_PIX_DELAY_SCAN", "DCS_UNIFORMITY_SCAN", 
+                                                                                                                                                                               "DDL_TEST", "GAIN", "PEDESTAL", "INJECTOR",  "LASER", "MONTECARLO", "NOISE", "NOISY_PIX_SCAN", 
+                                                                                                                                                                               "PHYSICS", "PULSER", "STANDALONE", "STANDALONE_BC", "STANDALONE_CENTRAL", "STANDALONE_COSMIC", 
+                                                                                                                                                                               "STANDALONE_EMD", "STANDALONE_LASER", "STANDALONE_MB", "STANDALONE_PEDESTAL", 
+                                                                                                                                                                               "STANDALONE_SEMICENTRAL", "STANDALONE_PULSER" } ;   
 TString       AliQA::fgTaskNames[]       = {"Raws", "Hits", "SDigits", "Digits", "RecPoints", "TrackSegments", "RecParticles", "ESDs"} ;   
-const TString AliQA::fgkLabLocalFile     = "file://"  ; 
-const TString AliQA::fgkLabLocalOCDB     = "local://" ;  
-const TString AliQA::fgkLabAliEnOCDB     = "alien://" ;  
-const TString AliQA::fgkRefFileName      = "QA.root" ; 
-const TString AliQA::fgkQAName           = "QA"  ; 
-const TString AliQA::fgkQACorrNtName     = "CorrQA" ;  
-const TString AliQA::fgkRefOCDBDirName   = "QA"  ; 
-TString AliQA::fgRefDataDirName                 = ""  ; 
-const TString AliQA::fgkQARefOCDBDefault = "alien://folder=/alice/QA/20"  ; 
-const TString AliQA::fgkExpert           = "Expert" ; 
-const UInt_t  AliQA::fgkExpertBit        = 16 ; 
-const UInt_t  AliQA::fgkQABit            = 17 ; 
+const TString AliQA::fkgLabLocalFile     = "file://"  ; 
+const TString AliQA::fkgLabLocalOCDB     = "local://" ;  
+const TString AliQA::fkgLabAliEnOCDB     = "alien://" ;  
+const TString AliQA::fkgRefFileName      = "QA.root" ; 
+const TString AliQA::fkgQAName           = "QA"  ; 
+const TString AliQA::fkgQACorrNtName     = "CorrQA" ;  
+const TString AliQA::fkgRefOCDBDirName   = "Ref"  ; 
+TString AliQA::fkgRefDataDirName              = ""  ; 
+const TString AliQA::fkgQARefOCDBDefault = "alien://folder=/alice/QA/20"  ; 
+const TString AliQA::fkgExpert           = "Expert" ; 
+const UInt_t  AliQA::fkgExpertBit        = 16 ; 
+const UInt_t  AliQA::fkgQABit            = 17 ; 
 
 //____________________________________________________________________________
 AliQA::AliQA() : 
   TNamed("", ""), 
   fNdet(kNDET), 
-  fNEventSpecies(AliRecoParam::kNSpecies), 
-  fLengthQA(fNdet*fNEventSpecies),
-  fQA(new ULong_t[fLengthQA]), 
+  fQA(new ULong_t[fNdet]), 
   fDet(kNULLDET),
-  fTask(kNULLTASK), 
-  fEventSpecie(AliRecoParam::kDefault), 
-  fEventSpecies(new Bool_t[fNEventSpecies])
+  fTask(kNULLTASK)
+       
 {
   // default constructor
-  memset(fQA,0,fLengthQA*sizeof(ULong_t));
-  memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+  // beware singleton: not to be used
+  
+  for (Int_t index = 0 ; index < fNdet ; index++) 
+       fQA[index] = 0 ; 
 }
 
 //____________________________________________________________________________
 AliQA::AliQA(const AliQA& qa) :
   TNamed(qa),
   fNdet(qa.fNdet), 
-  fNEventSpecies(qa.fNEventSpecies), 
-  fLengthQA(qa.fLengthQA),
-  fQA(new ULong_t[fLengthQA]), 
+  fQA(qa.fQA), 
   fDet(qa.fDet),
-  fTask(qa.fTask), 
-  fEventSpecie(qa.fEventSpecie), 
-  fEventSpecies(new Bool_t[fNEventSpecies])
+  fTask(qa.fTask)
 { 
   // cpy ctor
-  memcpy(fQA,qa.fQA,fLengthQA*sizeof(ULong_t));
-  memcpy(fEventSpecies,qa.fEventSpecies,fNEventSpecies*sizeof(Bool_t));
 }
 
 //_____________________________________________________________________________
 AliQA& AliQA::operator = (const AliQA& qa)
 {
-  // assignment operator
-  if(&qa != this) {
-    TNamed::operator=(qa);
-    fNdet          = qa.fNdet;
-    fNEventSpecies = qa.fNEventSpecies; 
-    fLengthQA      = qa.fLengthQA;
-
-    if(fQA) delete [] fQA;
-    fQA = new ULong_t[fLengthQA];
-    memcpy(fQA,qa.fQA,fLengthQA*sizeof(ULong_t));
-
-    fDet = qa.fDet;
-    fTask = qa.fTask;
-    fEventSpecie = qa.fEventSpecie; 
-    if(fEventSpecies) delete [] fEventSpecies;
-    fEventSpecies = new Bool_t[fNEventSpecies];
-    memcpy(fEventSpecies,qa.fEventSpecies,fNEventSpecies*sizeof(Bool_t));
-  }  
-  return *this;
-}
+// assignment operator
 
-//_______________________________________________________________
-AliQA::AliQA(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es) :
-TNamed("QA", "Quality Assurance status"),
-fNdet(kNDET), 
-fNEventSpecies(eslength), 
-fLengthQA(qalength),
-fQA(new ULong_t[fLengthQA]), 
-fDet(kNULLDET),
-fTask(kNULLTASK), 
-fEventSpecie(AliRecoParam::kDefault), 
-fEventSpecies(new Bool_t[fNEventSpecies])
-{
-  // constructor to be used
-  memcpy(fQA, qa, fLengthQA*sizeof(ULong_t));
-  memcpy(fEventSpecies, es, fNEventSpecies*sizeof(Bool_t));
+  this->~AliQA();
+  new(this) AliQA(qa);
+  return *this;
 }
 
 //_______________________________________________________________
 AliQA::AliQA(const DETECTORINDEX_t det) :
   TNamed("QA", "Quality Assurance status"),
-  fNdet(kNDET), 
-  fNEventSpecies(AliRecoParam::kNSpecies), 
-  fLengthQA(fNdet*fNEventSpecies),
-  fQA(new ULong_t[fLengthQA]), 
+  fNdet(kNDET),  
+  fQA(new ULong_t[fNdet]), 
   fDet(det),
-  fTask(kNULLTASK), 
-  fEventSpecie(AliRecoParam::kDefault), 
-  fEventSpecies(new Bool_t[fNEventSpecies])
+  fTask(kNULLTASK) 
 {
   // constructor to be used
-  if (! CheckRange(det) ) fDet = kNULLDET ; 
-  memset(fQA,0,fLengthQA*sizeof(ULong_t));
-  memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+  if (! CheckRange(det) ) {
+    fDet = kNULLDET ; 
+    return ;
+  } 
+  Int_t index ; 
+  for (index = 0; index < fNdet; index++) 
+    fQA[index] = 0 ; 
 }
   
 //_______________________________________________________________
 AliQA::AliQA(const ALITASK_t tsk) :
-  TNamed("QA", "Quality Assurance status"),
-  fNdet(kNDET), 
-  fNEventSpecies(AliRecoParam::kNSpecies), 
-  fLengthQA(fNdet*fNEventSpecies),
-  fQA(new ULong_t[fLengthQA]), 
+  TNamed("QA", "Quality Assurance status"), 
+  fNdet(kNDET),
+  fQA(new ULong_t[fNdet]), 
   fDet(kNULLDET),
-  fTask(tsk), 
-  fEventSpecie(AliRecoParam::kDefault), 
-  fEventSpecies(new Bool_t[fNEventSpecies])
+  fTask(tsk)
 {
   // constructor to be used in the AliRoot module (SIM, REC, ESD or ANA)
-  if (! CheckRange(tsk) ) fTask = kNULLTASK ; 
-  memset(fQA,0,fLengthQA*sizeof(ULong_t));
-  memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+  if (! CheckRange(tsk) ) {
+    fTask = kNULLTASK ; 
+    return ;
+  } 
+  Int_t index ; 
+  for (index = 0; index < fNdet; index++) 
+    fQA[index] = 0 ; 
 }
 
 //____________________________________________________________________________
 AliQA::~AliQA() 
 {
   // dtor  
-  delete [] fQA;
-  delete [] fEventSpecies;
+  delete[] fQA ;
 }
 
 //_______________________________________________________________
@@ -213,7 +182,7 @@ Bool_t AliQA::CheckFatal() const
   Bool_t rv = kFALSE ;
   Int_t index ;
   for (index = 0; index < kNDET ; index++)
-    rv = rv || IsSet(DETECTORINDEX_t(index), fTask, fEventSpecie, kFATAL) ;
+    rv = rv || IsSet(DETECTORINDEX_t(index), fTask, kFATAL) ;
   return rv ;
 }
 
@@ -249,35 +218,10 @@ Bool_t AliQA::CheckRange(QABIT_t bit) const
   return rv ;
 }
 
-//_______________________________________________________________
-Bool_t AliQA::CheckRange(AliRecoParam::EventSpecie_t es) const
-{ 
-  // check if bit is in given bit range: 0-kNBit
-  Bool_t rv = kFALSE ; 
-  switch (es) {
-    case AliRecoParam::kDefault: 
-      rv = kTRUE ; 
-      break ; 
-    case AliRecoParam::kLowMult: 
-      rv = kTRUE ; 
-      break ; 
-    case AliRecoParam::kHighMult: 
-      rv = kTRUE ; 
-      break ; 
-    case AliRecoParam::kCosmic: 
-      rv = kTRUE ; 
-      break ; 
-    case AliRecoParam::kCalib: 
-      rv = kTRUE ; 
-      break ; 
-  }
-  if (!rv)
-    AliFatal(Form("Event Specie %d is not valid", es)) ;
-  return rv ;
-}
+
 
 //_______________________________________________________________
-const char * AliQA::GetAliTaskName(ALITASK_t tsk)
+char * AliQA::GetAliTaskName(ALITASK_t tsk)
 {
        // returns the char name corresponding to module index
        TString tskName ;
@@ -303,11 +247,11 @@ const char * AliQA::GetAliTaskName(ALITASK_t tsk)
                        tsk = kNULLTASK ; 
                        break ;
        }
-       return tskName.Data() ;
+       return Form("%s", tskName.Data()) ;
 }
 
 //_______________________________________________________________
-const char * AliQA::GetBitName(QABIT_t bit) const
+char * AliQA::GetBitName(QABIT_t bit) const
 {
        // returns the char name corresponding to bit 
        TString bitName ;
@@ -330,7 +274,7 @@ const char * AliQA::GetBitName(QABIT_t bit) const
                        bit = kNULLBit ; 
                        break ;
        }
-       return bitName.Data() ;
+       return Form("%s", bitName.Data()) ; 
 }
 
 //_______________________________________________________________
@@ -360,7 +304,7 @@ const char * AliQA::GetDetName(Int_t det)
 }
 
 //_______________________________________________________________
-TFile * AliQA::GetQADataFile(const char * name, Int_t run) 
+TFile * AliQA::GetQADataFile(const char * name, const Int_t run) 
 {
   // opens the file to store the detectors Quality Assurance Data Maker results
        const char * temp = Form("%s.%s.%d.root", name, fgQADataFileName.Data(), run) ; 
@@ -412,8 +356,8 @@ TFile * AliQA::GetQAResultFile()
        fgQAResultFile = 0x0 ; 
 //     if (!fgQAResultFile) { 
                TString dirName(fgQAResultDirName) ; 
-               if ( dirName.Contains(fgkLabLocalFile)) 
-                       dirName.ReplaceAll(fgkLabLocalFile, "") ;
+               if ( dirName.Contains(fkgLabLocalFile)) 
+                       dirName.ReplaceAll(fkgLabLocalFile, "") ;
                TString fileName(dirName + fgQAResultFileName) ; 
                TString opt("") ; 
                if ( !gSystem->AccessPathName(fileName) )
@@ -430,6 +374,25 @@ TFile * AliQA::GetQAResultFile()
 }
 
 //_______________________________________________________________
+const TString AliQA::GetRunTypeName(RUNTYPE_t rt) 
+{ 
+       TString rv("Invalid Run Type") ;        
+       if ( rt == kNULLTYPE ) {
+               rv = "Known RUN_TYPE are: \n" ; 
+               for (Int_t index = 0 ; index < kNTYPE; index++) {
+                       rv += Form("%2d -- %s\n", index, fgRTNames[index].Data()) ;  
+               }
+               printf("%s", rv.Data()) ; 
+               return "" ; 
+       }
+       else {
+               if ( rt > kNULLTYPE && rt < kNTYPE )
+                       rv = fgRTNames[rt] ; 
+       }
+       return rv ; 
+}
+
+//_______________________________________________________________
 AliQA::TASKINDEX_t AliQA::GetTaskIndex(const char * name) 
 {
        // returns the detector index corresponding to a given name
@@ -445,44 +408,32 @@ AliQA::TASKINDEX_t AliQA::GetTaskIndex(const char * name)
 }
 
 //_______________________________________________________________
-Bool_t AliQA::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, Int_t ies, QABIT_t bit) const 
-{
-  // Checks is the requested bit is set
-   
-  const AliRecoParam::EventSpecie_t es = AliRecoParam::Convert(ies) ; 
-  return IsSet(det, tsk, es, bit) ; 
-  
-}  
-
-//_______________________________________________________________
-Bool_t AliQA::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) const
+Bool_t AliQA::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit) const
 {
   // Checks is the requested bit is set
        
   CheckRange(det) ; 
   CheckRange(tsk) ;
   CheckRange(bit) ;
-  CheckRange(es) ;
        
   ULong_t offset = Offset(tsk) ;
-  ULong_t status = GetStatus(det, es) ;
+  ULong_t status = GetStatus(det) ;
   offset+= bit ;
   status = (status & 1 << offset) != 0 ;
   return status ;
 }
 
 //_______________________________________________________________
-Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) const
+Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk) const
 {
   // Checks is the requested bit is set
        
   CheckRange(det) ; 
   CheckRange(tsk) ;
-  CheckRange(es) ;
        
   ULong_t offset = Offset(tsk) ;
-  ULong_t status = GetStatus(det, es) ;
-       ULong_t st = 0 ; 
+  ULong_t status = GetStatus(det) ;
+       UShort_t st = 0 ; 
        for ( Int_t bit = 0 ; bit < kNBIT ; bit++) {
                offset+= bit ;
                st += (status & 1 << offset) != 0 ;             
@@ -493,15 +444,14 @@ Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSp
                return kTRUE ;
 }
 //_______________________________________________________________
-Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es) const
+Bool_t AliQA::IsSetAny(DETECTORINDEX_t det) const
 {
   // Checks is the requested bit is set
        
   CheckRange(det) ; 
-  CheckRange(es) ; 
        
-       ULong_t status = GetStatus(det, es) ;
-       ULong_t st = 0 ; 
+       ULong_t status = GetStatus(det) ;
+       UShort_t st = 0 ; 
        for ( Int_t tsk = 0 ; tsk < kNTASK ; tsk++) {
                ULong_t offset = Offset(ALITASK_t(tsk)) ;
                for ( Int_t bit = 0 ; bit < kNBIT ; bit++) {
@@ -518,24 +468,9 @@ Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es) cons
 //_______________________________________________________________
 AliQA * AliQA::Instance()
 {
-  // Get an instance of the singleton. The only authorized way to call the ctor
+  // Get an instance of the singleton.
+  // Object must have been instantiated with Instance(ALITASK) first
 
-  if ( ! fgQA) {
-    TFile * f = GetQAResultFile() ; 
-    fgQA = dynamic_cast<AliQA *>(f->Get("QA")) ; 
-    if ( ! fgQA ) 
-      fgQA = new AliQA() ;
-  }    
-  return fgQA ;
-}
-
-//_______________________________________________________________
-AliQA * AliQA::Instance(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es)
-{
-  // Get an instance of the singleton. The only authorized way to call the ctor
-  
-  if ( ! fgQA) 
-    fgQA = new AliQA(qalength, qa, eslength, es) ;
   return fgQA ;
 }
 
@@ -557,7 +492,7 @@ AliQA * AliQA::Instance(const DETECTORINDEX_t det)
 //_______________________________________________________________
 AliQA * AliQA::Instance(const ALITASK_t tsk)
 {
-  // Get an instance of the singleton. The only authorized way to call the ctor
+  // get an instance of the singleton.
 
   if ( ! fgQA)
     switch (tsk) {
@@ -617,10 +552,8 @@ void AliQA::Merge(TCollection * list) {
                                TIter next(list) ;
                                AliQA * qa ; 
                                while ( (qa = (AliQA*)next() ) ) {
-          for (Int_t es = 0 ; es < fNEventSpecies ; es++) {
-            if (qa->IsSet(DETECTORINDEX_t(det), ALITASK_t(task), es, QABIT_t(bit)))
-              Set(QABIT_t(bit), es) ; 
-          }
+                                       qa->IsSet(DETECTORINDEX_t(det), ALITASK_t(task), QABIT_t(bit)) ;
+                                       Set(QABIT_t(bit)) ; 
                                } // qa list
                        } // bit
                } // task
@@ -661,26 +594,11 @@ ULong_t AliQA::Offset(ALITASK_t tsk) const
 }
 
 //_______________________________________________________________
-void AliQA::ResetStatus(DETECTORINDEX_t det) 
-{ 
-  // reset the status of det for all event specie
-  for (Int_t es = 0 ; es < fNEventSpecies ; es++)
-    fQA[det*fNdet+es] = 0 ; 
-}
-
-//_______________________________________________________________
-void AliQA::Set(QABIT_t bit, Int_t ies)
+void AliQA::Set(QABIT_t bit)
 {
-  // Set the status bit of the current detector in the current module and for the current event specie 
-   Set(bit, AliRecoParam::Convert(ies)) ;
-}
-
-//_______________________________________________________________
-void AliQA::Set(QABIT_t bit, AliRecoParam::EventSpecie_t es)
-{
-  // Set the status bit of the current detector in the current module and for the current event specie 
+  // Set the status bit of the current detector in the current module
   
-  SetStatusBit(fDet, fTask, es, bit) ;
+  SetStatusBit(fDet, fTask, bit) ;
 }
 
 //_____________________________________________________________________________
@@ -689,12 +607,12 @@ void AliQA::SetQARefStorage(const char * name)
        // Set the root directory where the QA reference data are stored
 
        fgQARefDirName = name ; 
-       if ( fgQARefDirName.Contains(fgkLabLocalFile) )
-               fgQARefFileName =  fgkRefFileName ; 
-       else if ( fgQARefDirName.Contains(fgkLabLocalOCDB) )
-               fgQARefFileName =  fgkQAName ; 
-       else if ( fgQARefDirName.Contains(fgkLabAliEnOCDB) )
-               fgQARefFileName =  fgkQAName ; 
+       if ( fgQARefDirName.Contains(fkgLabLocalFile) )
+               fgQARefFileName =  fkgRefFileName ; 
+       else if ( fgQARefDirName.Contains(fkgLabLocalOCDB) )
+               fgQARefFileName =  fkgQAName ; 
+       else if ( fgQARefDirName.Contains(fkgLabAliEnOCDB) )
+               fgQARefFileName =  fkgQAName ; 
 
   else {
          printf("ERROR: %s is an invalid storage definition\n", name) ; 
@@ -706,70 +624,72 @@ void AliQA::SetQARefStorage(const char * name)
 }
 
 //_____________________________________________________________________________
+void AliQA::SetQARefDataDirName(const char * name) 
+{
+  // Set the lower level directory name where reference data are found
+  TString test(name) ; 
+  RUNTYPE_t rt = kNULLTYPE ; 
+  for (Int_t index = 0; index < kNTYPE; index++) {
+    if (test.CompareTo(fgRTNames[index]) == 0) {
+      rt = (RUNTYPE_t) index ; 
+      break ; 
+    } 
+       }
+       
+       if (rt == kNULLTYPE) {
+      printf("AliQA::SetQARefDataDirName: %s is an unknown RUN TYPE name\n", name) ; 
+      return ; 
+       }
+       SetQARefDataDirName(rt) ; 
+}
+
+//_____________________________________________________________________________
 void AliQA::SetQAResultDirName(const char * name)
 {
   // Set the root directory where to store the QA status object
 
   fgQAResultDirName.Prepend(name) ; 
   printf("AliQA::SetQAResultDirName: QA results are in  %s\n", fgQAResultDirName.Data()) ;
-  if ( fgQAResultDirName.Contains(fgkLabLocalFile)) 
-    fgQAResultDirName.ReplaceAll(fgkLabLocalFile, "") ;
+  if ( fgQAResultDirName.Contains(fkgLabLocalFile)) 
+    fgQAResultDirName.ReplaceAll(fkgLabLocalFile, "") ;
   fgQAResultFileName.Prepend(fgQAResultDirName) ;
 }
 
 //_______________________________________________________________
-void AliQA::SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit)
+void AliQA::SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit)
 {
  // Set the status bit for a given detector and a given task
 
   CheckRange(det) ;
   CheckRange(tsk) ;
   CheckRange(bit) ;
-  CheckRange(es) ;
 
   ULong_t offset = Offset(tsk) ;
-  ULong_t status = GetStatus(det, es) ;
+  ULong_t status = GetStatus(det) ;
   offset+= bit ;
   status = status | 1 << offset ;
-  SetStatus(det, es, status) ;
+  SetStatus(det, status) ;
 }
 
 //_______________________________________________________________
-void AliQA::Show(DETECTORINDEX_t det) const 
-{ 
-  // dispplay the QA status word
-  if ( det == kNULLDET) 
-    det = fDet ;  
-  for (Int_t ies = 0 ; ies < fNEventSpecies ; ies++) {
-    const Bool_t what = IsEventSpecieSet(ies) ;
-    if ( what )
-      ShowStatus(det, kNULLTASK, AliRecoParam::Convert(ies)) ; 
-  }
-}
-
-//_______________________________________________________________
-void AliQA::ShowAll() const 
+void AliQA::ShowAll() const
 {
   // dispplay the QA status word
   Int_t index ;
   for (index = 0 ; index < kNDET ; index++) {
                for (Int_t tsk = kRAW ; tsk < kNTASK ; tsk++) {
-      for (Int_t ies = 0 ; ies < fNEventSpecies ; ies++) {
-        const Bool_t what = IsEventSpecieSet(ies) ;
-        if ( what )
-          ShowStatus(DETECTORINDEX_t(index), ALITASK_t(tsk), AliRecoParam::Convert(ies)) ;
-      }
-    }
+                       ShowStatus(DETECTORINDEX_t(index), ALITASK_t(tsk)) ;
+               }
        }
 }
 
 //_______________________________________________________________
-void AliQA::ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) const
+void AliQA::ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk) const
 {
        // Prints the full QA status of a given detector
        CheckRange(det) ;
-       CheckRange(es) ;
-       ULong_t status = GetStatus(det, es) ;
+       ULong_t status = GetStatus(det) ;
        ULong_t tskStatus[kNTASK] ; 
        tskStatus[kRAW] = status & 0x0000f ;
        tskStatus[kSIM] = status & 0x000f0 ;
@@ -777,60 +697,52 @@ void AliQA::ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSp
        tskStatus[kESD] = status & 0x0f000 ;
        tskStatus[kANA] = status & 0xf0000 ;
 
-       AliInfo(Form("====> QA Status for %8s %8s raw =0x%x, sim=0x%x, rec=0x%x, esd=0x%x, ana=0x%x", GetDetName(det).Data(), AliRecoParam::GetEventSpecieName(es), 
+       AliInfo(Form("====> QA Status for %8s raw =0x%x, sim=0x%x, rec=0x%x, esd=0x%x, ana=0x%x", GetDetName(det).Data(), 
                                 tskStatus[kRAW], tskStatus[kSIM], tskStatus[kREC], tskStatus[kESD], tskStatus[kANA] )) ;
        if (tsk == kNULLTASK) {
                for (Int_t itsk = kRAW ; itsk < kNTASK ; itsk++) {
-                       ShowASCIIStatus(es, det, ALITASK_t(itsk), tskStatus[itsk]) ; 
+                       ShowASCIIStatus(det, ALITASK_t(itsk), tskStatus[itsk]) ; 
                } 
        } else {
-                       ShowASCIIStatus(es, det, tsk, tskStatus[tsk]) ; 
+                       ShowASCIIStatus(det, tsk, tskStatus[tsk]) ; 
        }
 }
 
 //_______________________________________________________________
-void AliQA::ShowASCIIStatus(AliRecoParam::EventSpecie_t es, DETECTORINDEX_t det, ALITASK_t tsk, const ULong_t status) const 
+void AliQA::ShowASCIIStatus(DETECTORINDEX_t det, ALITASK_t tsk, const ULong_t status) const 
 {
        // print the QA status in human readable format
        TString text; 
        for (Int_t bit = kINFO ; bit < kNBIT ; bit++) {
-               if (IsSet(det, tsk, es, QABIT_t(bit))) {
+               if (IsSet(det, tsk, QABIT_t(bit))) {
                        text = GetBitName(QABIT_t(bit)) ; 
                        text += " " ; 
                }
        }
        if (! text.IsNull())
-               printf("           %8s %8s %4s 0x%4lx, Problem signalled: %8s \n", AliRecoParam::GetEventSpecieName(es), GetDetName(det).Data(), GetAliTaskName(tsk), status, text.Data()) ; 
+               printf("           %8s %4s 0x%4lx, Problem signalled: %8s \n", GetDetName(det).Data(), GetAliTaskName(tsk), status, text.Data()) ; 
 }
 
 //_______________________________________________________________
-void AliQA::UnSet(QABIT_t bit, Int_t ies)
-{
-       // UnSet the status bit of the current detector in the current module
-               UnSet(bit, AliRecoParam::Convert(ies)) ;
-}
-
-//_______________________________________________________________
-void AliQA::UnSet(QABIT_t bit, AliRecoParam::EventSpecie_t es)
+void AliQA::UnSet(QABIT_t bit)
 {
        // UnSet the status bit of the current detector in the current module
        
-       UnSetStatusBit(fDet, fTask, es, bit) ;
+       UnSetStatusBit(fDet, fTask, bit) ;
 }
 
 //_______________________________________________________________
-void AliQA::UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit)
+void AliQA::UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit)
 {
        // UnSet the status bit for a given detector and a given task
        
        CheckRange(det) ;
        CheckRange(tsk) ;
        CheckRange(bit) ;
-       CheckRange(es) ;
        
        ULong_t offset = Offset(tsk) ;
-       ULong_t status = GetStatus(det, es) ;
+       ULong_t status = GetStatus(det) ;
        offset+= bit ;
        status = status & 0 << offset ;
-       SetStatus(det, es, status) ;
-}
+       SetStatus(det, status) ;
+}
\ No newline at end of file
index 3708fad..d3acdae 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef ALIQA_H
 #define ALIQA_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
+* See cxx source for full Copyright notice                               */
 
 /* $Id$ */
 
 //
 
 #include <TNamed.h> 
-#include <TMath.h> 
 class TFile ; 
 
 #include "AliLog.h"
-#include "AliRecoParam.h"
 
 class AliQA : public TNamed {
 public:
   
-  enum DETECTORINDEX_t {
+       enum DETECTORINDEX_t {
     kNULLDET=-1, kITS, kTPC, kTRD, kTOF, kPHOS, kHMPID, kEMCAL, kMUON, kFMD,
     kZDC, kPMD, kT0, kVZERO, kACORDE, kHLT, kGLOBAL, kCORR, kNDET};
-  enum ALITASK_t {
+       enum ALITASK_t {
     kNULLTASK=-1, kRAW, kSIM, kREC, kESD, kANA, kNTASK };
-  enum QABIT_t {
+       enum QABIT_t {
     kNULLBit=-1, kINFO, kWARNING, kERROR, kFATAL, kNBIT };
-  enum TASKINDEX_t {
+  enum RUNTYPE_t {
+    kNULLTYPE=-1, kUNKOWN, kAUTO_TEST, kCALIBRATION, kCALIBRATION_PULSER, kCHANNEL_DELAY_TUNING, kCOSMIC, kCOSMICS, kDAQ_FO_UNIF_SCAN, 
+    kDAQ_GEN_DAC_SCAN, kDAQ_MEAN_TH_SCAN, kDAQ_MIN_TH_SCAN, kDAQ_NOISY_PIX_SCAN, kDAQ_PIX_DELAY_SCAN, kDAQ_UNIFORMITY_SCAN, 
+    kDCS_FO_UNIF_SCAN, kDCS_MEAN_TH_SCAN, kDCS_MIN_TH_SCAN, kDCS_PIX_DELAY_SCAN, kDCS_UNIFORMITY_SCAN, kDDL_TEST, kGAIN, 
+    kPEDESTAL, kINJECTOR,  kLASER, kMONTECARLO, kNOISE, kNOISY_PIX_SCAN,  kPHYSICS, kPULSER, kSTANDALONE, kSTANDALONE_BC, 
+    kSTANDALONE_CENTRAL, kSTANDALONE_COSMIC, kSTANDALONE_EMD, kSTANDALONE_LASER, kSTANDALONE_MB, kSTANDALONE_PEDESTAL, 
+    kSTANDALONE_SEMICENTRAL, kSTANDALONE_PULSER, kNTYPE};
+       
+       enum TASKINDEX_t {
     kNULLTASKINDEX=-1, kRAWS, kHITS, kSDIGITS, kDIGITS, kRECPOINTS, kTRACKSEGMENTS, kRECPARTICLES, kESDS, kNTASKINDEX };
   
-  // Creators - destructors
-  AliQA(); // beware singleton, not to be used
-  AliQA(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es) ;
-  AliQA(const ALITASK_t tsk) ;
-  AliQA(const DETECTORINDEX_t det) ;
-  AliQA(const AliQA& qa) ;   
-  AliQA& operator = (const AliQA& qa) ;
-  virtual ~AliQA();
+       // Creators - destructors
+       AliQA(); // beware singleton, not to be used
+       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 Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es) ;
-  static  AliQA *        Instance(const DETECTORINDEX_t det) ;
-  static  AliQA *        Instance(const ALITASK_t tsk) ;
-  static  AliQA *        Instance(const TASKINDEX_t tsk) ;
+       static  AliQA *        Instance() ;
+       static  AliQA *        Instance(const DETECTORINDEX_t det) ;
+       static  AliQA *        Instance(const ALITASK_t tsk) ;
+       static  AliQA *        Instance(const TASKINDEX_t tsk) ;
   Bool_t                 CheckFatal() const ;
-  static void            Close() ; 
-  static const char *    GetAliTaskName(ALITASK_t tsk) ;
-  Bool_t *               GetEventSpecies() { return fEventSpecies ; }
-  static const TString   GetExpert() { return fgkExpert ; }
-  static       UInt_t    GetExpertBit() { return fgkExpertBit ; }
-  static const TString   GetLabLocalFile() { return fgkLabLocalFile ; } 
-  static const TString   GetLabLocalOCDB() { return fgkLabLocalOCDB ; } 
-  static const TString   GetLabAliEnOCDB() { return fgkLabAliEnOCDB ; } 
-  static DETECTORINDEX_t GetDetIndex(const char * name) ; 
-  static const TString   GetDetName(DETECTORINDEX_t det) { return fgDetNames[det] ; }
-  static const char *    GetDetName(Int_t det) ;
-  static const TString   GetGRPPath() { return fgGRPPath ; }  
-  ULong_t *              GetQA() { return fQA ; }
-  static       UInt_t    GetQABit() { return fgkQABit ; }
-  static TFile *         GetQADataFile(const char * name, Int_t run) ; 
-  static TFile *              GetQADataFile(const char * fileName) ;
-  static const char *    GetQADataFileName(const char * name, Int_t run) 
-  {return Form("%s.%s.%d.root", name, fgQADataFileName.Data(), run)  ; }
-  static const char *    GetQADataFileName() { return fgQADataFileName.Data() ; }
-  static const char *    GetQAName() { return fgkQAName ; } 
-  static const char *    GetQACorrName() { return fgkQACorrNtName ; }
-  static TFile *         GetQAResultFile() ; 
-  static const char  *   GetQAResultFileName() { return (fgQAResultDirName + fgQAResultFileName).Data() ; }
-  static const char  *   GetQARefDefaultStorage() { return fgkQARefOCDBDefault.Data() ; }
-  static const char  *   GetQARefFileName() { return fgQARefFileName ; }
-  static const char  *   GetQARefStorage() { return fgQARefDirName.Data() ; }
-  static const char  *   GetRefOCDBDirName() { return fgkRefOCDBDirName.Data() ; }
-  static const char  *   GetRefDataDirName() { return fgRefDataDirName.Data() ; }
-  static     TASKINDEX_t GetTaskIndex(const char * name) ; 
-  static       TString   GetTaskName(UInt_t tsk) { return fgTaskNames[tsk] ; }
-  Bool_t                 IsEventSpecieSet(AliRecoParam::EventSpecie_t es) const 
-  {Int_t ibit=0; while(es!=1<<ibit) ++ibit; return fEventSpecies[ibit];}
-  Bool_t                 IsEventSpecieSet(Int_t es) const { return fEventSpecies[es] ; }
-  Bool_t                 IsSet(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) const ;
-  Bool_t                 IsSet(DETECTORINDEX_t det, ALITASK_t tsk, Int_t es, QABIT_t bit) const ;
-  Bool_t                 IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) const ;
-  Bool_t                 IsSetAny(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es) const ;
-  void                   Merge(TCollection * list) ; 
-  void                   Set(QABIT_t bit, AliRecoParam::EventSpecie_t es) ;
-  void                   Set(QABIT_t bit, Int_t es) ;
-  void                   SetEventSpecie(AliRecoParam::EventSpecie_t es) 
-  {Int_t ibit=0; while(es!=1<<ibit) ++ibit; fEventSpecies[ibit] = kTRUE ; }
-  static void            SetQAResultDirName(const char * name) ; 
-  static void            SetQARefStorage(const char * name) ; 
-  static void            SetQARefDataDirName(AliRecoParam::EventSpecie_t es) { fgRefDataDirName = AliRecoParam::GetEventSpecieName(es) ; }
-  static void            SetQARefDataDirName(Int_t es) { fgRefDataDirName = AliRecoParam::GetEventSpecieName(es) ; }
-  void                   Show(DETECTORINDEX_t det = kNULLDET) const ;
-  void                   ShowAll() const ;
-  void                   ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk=kNULLTASK, AliRecoParam::EventSpecie_t es=AliRecoParam::kDefault) const ;
-  void                   UnSet(QABIT_t bit, AliRecoParam::EventSpecie_t es) ;
-  void                   UnSet(QABIT_t bit, Int_t es) ;
+       static void            Close() ; 
+       static  char *         GetAliTaskName(ALITASK_t tsk) ;
+  static const TString   GetExpert() { return fkgExpert ; }
+  static  UInt_t         GetExpertBit() { return fkgExpertBit ; }
+       static const TString   GetLabLocalFile() { return fkgLabLocalFile ; } 
+       static const TString   GetLabLocalOCDB() { return fkgLabLocalOCDB ; } 
+       static const TString   GetLabAliEnOCDB() { return fkgLabAliEnOCDB ; } 
+       static  DETECTORINDEX_t GetDetIndex(const char * name) ; 
+       static const TString   GetDetName(DETECTORINDEX_t det) { return fgDetNames[det] ; }
+       static const char *    GetDetName(Int_t det) ;
+       static const TString   GetGRPPath() { return fgGRPPath ; }  
+  static  UInt_t         GetQABit() { return fkgQABit ; }
+       static TFile *         GetQADataFile(const char * name, const Int_t run) ; 
+       static TFile *         GetQADataFile(const char * fileName) ;
+       static const char *    GetQADataFileName(const char * name, const Int_t run) 
+    {return Form("%s.%s.%d.root", name, fgQADataFileName.Data(), run)  ; }
+       static const char *    GetQADataFileName() { return fgQADataFileName.Data() ; }
+       static const char *    GetQAName() { return fkgQAName ; } 
+  static const char *    GetQACorrName() { return fkgQACorrNtName ; }
+       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  *   GetRefOCDBDirName() { return fkgRefOCDBDirName.Data() ; }
+       static const char  *   GetRefDataDirName() { return fkgRefDataDirName.Data() ; }
+       static const TString   GetRunTypeName(RUNTYPE_t rt = kNULLTYPE) ;
+       static  TASKINDEX_t    GetTaskIndex(const char * name) ; 
+       static const TString   GetTaskName(UInt_t tsk) { return fgTaskNames[tsk] ; }
+  Bool_t                 IsSet(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit) const ;
+  Bool_t                 IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk) const ;
+  Bool_t                 IsSetAny(DETECTORINDEX_t det) const ;
+       void                   Merge(TCollection * list) ; 
+       void                   Set(QABIT_t bit) ;
+       static void                            SetQAResultDirName(const char * name) ; 
+       static void            SetQARefStorage(const char * name) ; 
+       static void            SetQARefDataDirName(RUNTYPE_t rt) { fkgRefDataDirName = GetRunTypeName(rt) ; }
+       static void            SetQARefDataDirName(const char * name) ;
+       void                   Show() const { ShowStatus(fDet, fTask) ; }
+       void                   Show(DETECTORINDEX_t det) const { ShowStatus(det) ; }
+       void                   ShowAll() const ;
+       void                   UnSet(QABIT_t bit) ;
   
 private:      
+    
+  Bool_t               CheckRange(DETECTORINDEX_t det) const ;
+  Bool_t               CheckRange(ALITASK_t tsk) const ;
+  Bool_t               CheckRange(QABIT_t bit) const ;
+  char *               GetBitName(QABIT_t bit) const ;
+  ULong_t              GetStatus(DETECTORINDEX_t det) const  { return fQA[det] ;}
+       void                 Finish() const ;  
+  ULong_t              Offset(ALITASK_t tsk) const ;
+       void                 ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk=kNULLTASK) const ;
+       void                 ShowASCIIStatus(DETECTORINDEX_t det, ALITASK_t tsk, ULong_t status) 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) ;
   
-  Bool_t                CheckRange(DETECTORINDEX_t det) const ;
-  Bool_t                CheckRange(ALITASK_t tsk) const ;
-  Bool_t                CheckRange(QABIT_t bit) const ;
-  Bool_t                CheckRange(AliRecoParam::EventSpecie_t es) const ;
-  const char *          GetBitName(QABIT_t bit) const ;
-  ULong_t               GetStatus(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es) const  { return fQA[det*fNEventSpecies+(Int_t)TMath::Log2(es)] ;}
-  void                  Finish() const ;  
-  ULong_t               Offset(ALITASK_t tsk) const ;
-  void                  ShowASCIIStatus(AliRecoParam::EventSpecie_t es, DETECTORINDEX_t det, ALITASK_t tsk, ULong_t status) const ; 
-  void                  ResetStatus(DETECTORINDEX_t det) ; 
-  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, AliRecoParam::EventSpecie_t es, ULong_t status) { fQA[det*fNEventSpecies+(Int_t)TMath::Log2(es)] = status ; }
-  void                  SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) ;
-  void                  UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, 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_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 TString       fgGRPPath              ; //! path of the GRP object in OCDB
+       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       fgRTNames[]                  ; //! list of Run Type names   
+       static TString       fgTaskNames[]              ; //! list of tasks names   
+  static const TString fkgExpert              ; //! name for the expert directory
+  static const UInt_t  fkgExpertBit           ; //! TObject bit identifing the object as "expert"
+       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 UInt_t  fkgQABit               ; //! bit in the QA data object which is set when Checker does not return 0
+       static const TString fkgQAName              ; //! name of QA object 
+       static const TString fkgQACorrNtName        ; //! name of QA Correlation Ntuple
+       static const TString fkgRefOCDBDirName      ; //! name of Reference directory name in OCDB      
+       static       TString fkgRefDataDirName      ; //! name of Reference directory name in OCDB for data     
+       static const TString fkgQARefOCDBDefault    ; //! default storage for QA in OCDB 
   
-  static AliQA *       fgQA                            ; // pointer to the instance of the singleton
-  Int_t                fNdet                       ; // number of detectors
-  Int_t                fNEventSpecies         ; // number of Event Species (see AliRecoParam)
-  Int_t                fLengthQA              ; // Auxiliary length of fQA
-  ULong_t    *         fQA                             ; //[fLengthQA]  the status word 4 bits for SIM, REC, ESD, ANA each
-  DETECTORINDEX_t      fDet                            ; //! the current detector (ITS, TPC, ....)
-  ALITASK_t            fTask                   ; //! the current environment (SIM, REC, ESD, ANA)
-  AliRecoParam::EventSpecie_t fEventSpecie    ; //! the current event specie
-  static TString       fgDetNames[]              ; //! list of detector names   
-  static TString       fgGRPPath              ; //! path of the GRP object in OCDB
-  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       fgRTNames[]               ; //! list of Run Type names   
-  static TString       fgTaskNames[]           ; //! list of tasks names   
-  static const TString fgkExpert              ; //! name for the expert directory
-  static const UInt_t  fgkExpertBit           ; //! TObject bit identifing the object as "expert"
-  static const TString fgkLabLocalFile        ; //! label to identify a file as local 
-  static const TString fgkLabLocalOCDB        ; //! label to identify a file as local OCDB 
-  static const TString fgkLabAliEnOCDB        ; //! label to identify a file as AliEn OCDB 
-  static const TString fgkRefFileName         ; //! name of Reference File Name 
-  static const UInt_t  fgkQABit               ; //! bit in the QA data object which is set when Checker does not return 0
-  static const TString fgkQAName              ; //! name of QA object 
-  static const TString fgkQACorrNtName        ; //! name of QA Correlation Ntuple
-  static const TString fgkRefOCDBDirName      ; //! name of Reference directory name in OCDB   
-  static       TString fgRefDataDirName       ; //! name of Reference directory name in OCDB for data          
-  static const TString fgkQARefOCDBDefault    ; //! default storage for QA in OCDB 
-  Bool_t *             fEventSpecies          ; //[fNEventSpecies] list of event species encountered in a run
-
- ClassDef(AliQA,2)  //ALICE Quality Assurance Object
+  ClassDef(AliQA,1)  //ALICE Quality Assurance Object
 };
-#endif
+#endif
\ No newline at end of file
index 9c7256a..d53c8c5 100644 (file)
@@ -27,7 +27,7 @@
 #include "AliRunInfo.h" 
 #include "AliLog.h"
 #include "AliModule.h" 
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliQACheckerBase.h"
 #include "AliCorrQAChecker.h"
@@ -59,7 +59,7 @@ AliQAChecker::AliQAChecker(const char* name, const char* title) :
   fEventSpecie(AliRecoParam::kDefault) 
 {
   // ctor: initialise checkers and open the data file   
-  for (Int_t det = 0 ; det < AliQA::kNDET ; det++) 
+  for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) 
     fCheckers[det] = NULL ; 
 }
 
@@ -75,7 +75,7 @@ AliQAChecker::AliQAChecker(const AliQAChecker& qac) :
 {
   // copy constructor
   
-  for (Int_t det = 0 ; det < AliQA::kNDET ; det++) 
+  for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) 
     fCheckers[det] = NULL ; 
 }
 
@@ -96,7 +96,7 @@ AliQAChecker::~AliQAChecker()
   if (fRunInfo)
     delete fRunInfo ; 
   delete [] fCheckers ; 
-  AliQA::Close() ; 
+  AliQAv1::Close() ; 
 }
 
 //_____________________________________________________________________________
@@ -109,11 +109,11 @@ AliQAChecker::~AliQAChecker()
 
        AliQACheckerBase * qac = NULL ;
 
-       TString detName(AliQA::GetDetName(det)) ; 
+       TString detName(AliQAv1::GetDetName(det)) ; 
        
-       if (det == AliQA::kGLOBAL) {
+       if (det == AliQAv1::kGLOBAL) {
                qac = new AliGlobalQAChecker() ; 
-       } else if (det == AliQA::kCORR) {
+       } else if (det == AliQAv1::kCORR) {
                qac = new AliCorrQAChecker() ; 
        } else {
                AliDebug(1, Form("Retrieving QA checker for %s", detName.Data())) ; 
@@ -150,10 +150,10 @@ void AliQAChecker::GetRefSubDir(const char * det, const char * task, TDirectory
 { 
   // Opens and returns the file with the reference data 
   dirFile = NULL ; 
-  TString refStorage(AliQA::GetQARefStorage()) ;
-//  if (refStorage.Contains(AliQA::GetLabLocalFile())) {       
-//    refStorage.ReplaceAll(AliQA::GetLabLocalFile(), "") ; 
-//    refStorage += AliQA::GetQARefFileName() ;
+  TString refStorage(AliQAv1::GetQARefStorage()) ;
+//  if (refStorage.Contains(AliQAv1::GetLabLocalFile())) {     
+//    refStorage.ReplaceAll(AliQAv1::GetLabLocalFile(), "") ; 
+//    refStorage += AliQAv1::GetQARefFileName() ;
 //    if ( fRefFile ) 
 //      if ( fRefFile->IsOpen() ) 
 //                                     fRefFile->Close() ; 
@@ -171,27 +171,27 @@ void AliQAChecker::GetRefSubDir(const char * det, const char * task, TDirectory
 //                             AliWarning(Form("Directory %s/%s not found in %s", det, task, refStorage.Data())) ; 
 //    }  
 //  } else 
-  if (!refStorage.Contains(AliQA::GetLabLocalOCDB()) && !refStorage.Contains(AliQA::GetLabAliEnOCDB())) {
+  if (!refStorage.Contains(AliQAv1::GetLabLocalOCDB()) && !refStorage.Contains(AliQAv1::GetLabAliEnOCDB())) {
     AliError(Form("%s is not a valid location for reference data", refStorage.Data())) ; 
     return ; 
   } else {
     AliQAManager* manQA = AliQAManager::QAManager() ;
     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
-      if ( !AliQA::Instance()->IsEventSpecieSet(specie) ) 
+      if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) 
         continue ; 
-      //if ( strcmp(AliQA::GetRefDataDirName(), "") == 0 ) { // the name of the last level of the directory is not set (EventSpecie)
+      //if ( strcmp(AliQAv1::GetRefDataDirName(), "") == 0 ) { // the name of the last level of the directory is not set (EventSpecie)
         // Get it from RunInfo
         //if (!fRunInfo)  // not yet set, get the info from GRP
         //  LoadRunInfoFromGRP() ; 
-      AliQA::SetQARefDataDirName(specie) ;
+      AliQAv1::SetQARefDataDirName(specie) ;
       //}
       if ( ! manQA->GetLock() ) { 
-        manQA->SetDefaultStorage(AliQA::GetQARefStorage()) ; 
-        manQA->SetSpecificStorage("*", AliQA::GetQARefStorage()) ;
+        manQA->SetDefaultStorage(AliQAv1::GetQARefStorage()) ; 
+        manQA->SetSpecificStorage("*", AliQAv1::GetQARefStorage()) ;
         manQA->SetRun(AliCDBManager::Instance()->GetRun()) ; 
         manQA->SetLock() ; 
       }
-      char * detOCDBDir = Form("%s/%s/%s", det, AliQA::GetRefOCDBDirName(), AliQA::GetRefDataDirName()) ; 
+      char * detOCDBDir = Form("%s/%s/%s", det, AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName()) ; 
       AliCDBEntry * entry = manQA->Get(detOCDBDir, manQA->GetRun()) ;
       if (entry) {
         dirOCDB = new TObjArray*[AliRecoParam::kNSpecies] ;    
@@ -219,7 +219,7 @@ AliQAChecker * AliQAChecker::Instance()
 void AliQAChecker::LoadRunInfoFromGRP() 
 {
   AliCDBManager* man = AliCDBManager::Instance() ;
-  AliCDBEntry* entry = man->Get(AliQA::GetGRPPath().Data());
+  AliCDBEntry* entry = man->Get(AliQAv1::GetGRPPath().Data());
   AliGRPObject* grpObject = 0x0;
   if (entry) {
 
@@ -318,7 +318,7 @@ Bool_t AliQAChecker::Run(const char * fileName)
   stopwatch.Start();
 
   //search for all detectors QA directories
-  TList * detKeyList = AliQA::GetQADataFile(fileName)->GetListOfKeys() ; 
+  TList * detKeyList = AliQAv1::GetQADataFile(fileName)->GetListOfKeys() ; 
   TIter nextd(detKeyList) ; 
   TKey * detKey ; 
   while ( (detKey = dynamic_cast<TKey *>(nextd()) ) ) {
@@ -327,15 +327,15 @@ Bool_t AliQAChecker::Run(const char * fileName)
     TString detName ; 
     TString detNameQA(detKey->GetName()) ; 
     Int_t det ; 
-    for ( det = 0; det < AliQA::kNDET ; det++) {
-      detName = AliQA::GetDetName(det) ; 
+    for ( det = 0; det < AliQAv1::kNDET ; det++) {
+      detName = AliQAv1::GetDetName(det) ; 
       if (detNameQA.Contains(detName)) {
         fFoundDetectors+=detName ; 
         fFoundDetectors+="." ;         
         break ; 
       }
     } 
-    TDirectory * detDir = AliQA::GetQADataFile(fileName)->GetDirectory(detKey->GetName()) ; 
+    TDirectory * detDir = AliQAv1::GetQADataFile(fileName)->GetDirectory(detKey->GetName()) ; 
     TList * taskKeyList = detDir->GetListOfKeys() ;
     TIter nextt(taskKeyList) ; 
     TKey * taskKey ; 
@@ -350,22 +350,22 @@ 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_t index = AliQA::kNULLTASK ; 
-      if ( taskName == AliQA::GetTaskName(AliQA::kHITS) ) 
-        index = AliQA::kSIM ; 
-      if ( taskName == AliQA::GetTaskName(AliQA::kSDIGITS) ) 
-        index = AliQA::kSIM ; 
-      if ( taskName == AliQA::GetTaskName(AliQA::kDIGITS) ) 
-        index = AliQA::kSIM ; 
-      if ( taskName == AliQA::GetTaskName(AliQA::kRECPOINTS) ) 
-        index = AliQA::kREC ; 
-      if ( taskName == AliQA::GetTaskName(AliQA::kTRACKSEGMENTS) ) 
-        index = AliQA::kREC ; 
-      if ( taskName == AliQA::GetTaskName(AliQA::kRECPARTICLES) ) 
-        index = AliQA::kREC ; 
-      if ( taskName == AliQA::GetTaskName(AliQA::kESDS) ) 
-        index = AliQA::kESD ; 
-      qac->Init(AliQA::DETECTORINDEX_t(det)) ; 
+      AliQAv1::ALITASK_t index = AliQAv1::kNULLTASK ; 
+      if ( taskName == AliQAv1::GetTaskName(AliQAv1::kHITS) ) 
+        index = AliQAv1::kSIM ; 
+      if ( taskName == AliQAv1::GetTaskName(AliQAv1::kSDIGITS) ) 
+        index = AliQAv1::kSIM ; 
+      if ( taskName == AliQAv1::GetTaskName(AliQAv1::kDIGITS) ) 
+        index = AliQAv1::kSIM ; 
+      if ( taskName == AliQAv1::GetTaskName(AliQAv1::kRECPOINTS) ) 
+        index = AliQAv1::kREC ; 
+      if ( taskName == AliQAv1::GetTaskName(AliQAv1::kTRACKSEGMENTS) ) 
+        index = AliQAv1::kREC ; 
+      if ( taskName == AliQAv1::GetTaskName(AliQAv1::kRECPARTICLES) ) 
+        index = AliQAv1::kREC ; 
+      if ( taskName == AliQAv1::GetTaskName(AliQAv1::kESDS) ) 
+        index = AliQAv1::kESD ; 
+      qac->Init(AliQAv1::DETECTORINDEX_t(det)) ; 
       
       TDirectory * refDir     = NULL ; 
       TObjArray ** refOCDBDir = NULL ; 
@@ -375,10 +375,10 @@ Bool_t AliQAChecker::Run(const char * fileName)
     }
   }
   AliInfo("QA performed for following detectors:") ; 
-  for ( Int_t det = 0; det < AliQA::kNDET; det++) {
-    if (fFoundDetectors.Contains(AliQA::GetDetName(det))) {
-      printf("%s, ",AliQA::GetDetName(det)) ; 
-      fFoundDetectors.ReplaceAll(AliQA::GetDetName(det), "") ; 
+  for ( Int_t det = 0; det < AliQAv1::kNDET; det++) {
+    if (fFoundDetectors.Contains(AliQAv1::GetDetName(det))) {
+      printf("%s, ",AliQAv1::GetDetName(det)) ; 
+      fFoundDetectors.ReplaceAll(AliQAv1::GetDetName(det), "") ; 
     }  
   }
   printf("\n") ; 
@@ -386,76 +386,76 @@ Bool_t AliQAChecker::Run(const char * fileName)
 }
 
 //_____________________________________________________________________________
-Bool_t AliQAChecker::Run(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, TObjArray ** list)
+Bool_t AliQAChecker::Run(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
        // run the Quality Assurance Checker for detector det, for task task starting from data in list
 
        AliQACheckerBase * qac = GetDetQAChecker(det) ; 
        if (qac)
-               AliDebug(1, Form("QA checker found for %s", AliQA::GetDetName(det).Data())) ;
+               AliDebug(1, Form("QA checker found for %s", AliQAv1::GetDetName(det).Data())) ;
        if (!qac)
-               AliError(Form("QA checker not found for %s", AliQA::GetDetName(det).Data())) ; 
+               AliError(Form("QA checker not found for %s", AliQAv1::GetDetName(det).Data())) ; 
   
-       AliQA::ALITASK_t index = AliQA::kNULLTASK ; 
-       if ( task == AliQA::kRAWS ) 
-               index = AliQA::kRAW ; 
-       else if ( task == AliQA::kHITS ) 
-               index = AliQA::kSIM ; 
-       else if ( task == AliQA::kSDIGITS ) 
-               index = AliQA::kSIM ; 
-       else if ( task == AliQA::kDIGITS ) 
-               index = AliQA::kSIM ; 
-       else if ( task == AliQA::kRECPOINTS ) 
-               index = AliQA::kREC ; 
-       else if ( task == AliQA::kTRACKSEGMENTS ) 
-               index = AliQA::kREC ; 
-       else if ( task == AliQA::kRECPARTICLES ) 
-               index = AliQA::kREC ; 
-       else if ( task == AliQA::kESDS ) 
-               index = AliQA::kESD ; 
+       AliQAv1::ALITASK_t index = AliQAv1::kNULLTASK ; 
+       if ( task == AliQAv1::kRAWS ) 
+               index = AliQAv1::kRAW ; 
+       else if ( task == AliQAv1::kHITS ) 
+               index = AliQAv1::kSIM ; 
+       else if ( task == AliQAv1::kSDIGITS ) 
+               index = AliQAv1::kSIM ; 
+       else if ( task == AliQAv1::kDIGITS ) 
+               index = AliQAv1::kSIM ; 
+       else if ( task == AliQAv1::kRECPOINTS ) 
+               index = AliQAv1::kREC ; 
+       else if ( task == AliQAv1::kTRACKSEGMENTS ) 
+               index = AliQAv1::kREC ; 
+       else if ( task == AliQAv1::kRECPARTICLES ) 
+               index = AliQAv1::kREC ; 
+       else if ( task == AliQAv1::kESDS ) 
+               index = AliQAv1::kESD ; 
 
        TDirectory * refDir     = NULL ; 
        TObjArray ** refOCDBDir = NULL  ;       
   qac->Init(det) ; 
-  GetRefSubDir(AliQA::GetDetName(det), AliQA::GetTaskName(task), refDir, refOCDBDir) ;
+  GetRefSubDir(AliQAv1::GetDetName(det), AliQAv1::GetTaskName(task), refDir, refOCDBDir) ;
   qac->SetRefandData(refDir, refOCDBDir) ; 
   qac->Run(index, list) ; 
        return kTRUE ; 
 }
 
 //_____________________________________________________________________________
-Bool_t AliQAChecker::Run(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, TNtupleD ** list)
+Bool_t AliQAChecker::Run(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, TNtupleD ** list)
 {
        // run the Quality Assurance Checker for detector det, for task task starting from data in list
   
        AliQACheckerBase * qac = GetDetQAChecker(det) ; 
        if (qac)
-               AliDebug(1, Form("QA checker found for %s", AliQA::GetDetName(det).Data())) ;
+               AliDebug(1, Form("QA checker found for %s", AliQAv1::GetDetName(det).Data())) ;
        if (!qac)
-               AliError(Form("QA checker not found for %s", AliQA::GetDetName(det).Data())) ; 
+               AliError(Form("QA checker not found for %s", AliQAv1::GetDetName(det).Data())) ; 
   
-       AliQA::ALITASK_t index = AliQA::kNULLTASK ; 
-       if ( task == AliQA::kRAWS ) 
-               index = AliQA::kRAW ; 
-       else if ( task == AliQA::kHITS ) 
-               index = AliQA::kSIM ; 
-       else if ( task == AliQA::kSDIGITS ) 
-               index = AliQA::kSIM ; 
-       else if ( task == AliQA::kDIGITS ) 
-               index = AliQA::kSIM ; 
-       else if ( task == AliQA::kRECPOINTS ) 
-               index = AliQA::kREC ; 
-       else if ( task == AliQA::kTRACKSEGMENTS ) 
-               index = AliQA::kREC ; 
-       else if ( task == AliQA::kRECPARTICLES ) 
-               index = AliQA::kREC ; 
-       else if ( task == AliQA::kESDS ) 
-               index = AliQA::kESD ; 
+       AliQAv1::ALITASK_t index = AliQAv1::kNULLTASK ; 
+       if ( task == AliQAv1::kRAWS ) 
+               index = AliQAv1::kRAW ; 
+       else if ( task == AliQAv1::kHITS ) 
+               index = AliQAv1::kSIM ; 
+       else if ( task == AliQAv1::kSDIGITS ) 
+               index = AliQAv1::kSIM ; 
+       else if ( task == AliQAv1::kDIGITS ) 
+               index = AliQAv1::kSIM ; 
+       else if ( task == AliQAv1::kRECPOINTS ) 
+               index = AliQAv1::kREC ; 
+       else if ( task == AliQAv1::kTRACKSEGMENTS ) 
+               index = AliQAv1::kREC ; 
+       else if ( task == AliQAv1::kRECPARTICLES ) 
+               index = AliQAv1::kREC ; 
+       else if ( task == AliQAv1::kESDS ) 
+               index = AliQAv1::kESD ; 
   
        TDirectory * refDir     = NULL ; 
        TObjArray ** refOCDBDir = NULL ;        
   qac->Init(det) ; 
-  GetRefSubDir(AliQA::GetDetName(det), AliQA::GetTaskName(task), refDir, refOCDBDir) ;
+  GetRefSubDir(AliQAv1::GetDetName(det), AliQAv1::GetTaskName(task), refDir, refOCDBDir) ;
   qac->SetRefandData(refDir, refOCDBDir) ; 
   qac->Run(index, list) ; 
   return kTRUE ; 
index 11fddce..e17e237 100644 (file)
@@ -18,7 +18,7 @@
 #include <TFile.h>  
 class TNtupleD ;
 
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliRecoParam.h"
 class AliCDBEntry ; 
 class AliRunInfo ;
@@ -41,8 +41,8 @@ public:
 //  void                   SetRefDirName(const char * name) ; 
 
   virtual Bool_t Run(const char * fileName = NULL) ;
-  virtual Bool_t Run(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, TObjArray ** list);
-  virtual Bool_t Run(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, TNtupleD ** list);
+  virtual Bool_t Run(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, TObjArray ** list);
+  virtual Bool_t Run(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, TNtupleD ** list);
   void SetRunInfo(AliRunInfo * ei) {fRunInfo = ei;}
 
 private:
@@ -55,7 +55,7 @@ private:
   Bool_t                      fRunInfoOwner;            //! owns fRunInfo or not
   TFile *                     fRefFile ;                //! Reference Data file 
   TString                     fFoundDetectors ;         //! detectors for which the Quality assurance could be done
-  AliQACheckerBase *          fCheckers[AliQA::kNDET] ; //! list of detectors checkers
+  AliQACheckerBase *          fCheckers[AliQAv1::kNDET] ; //! list of detectors checkers
   AliRecoParam::EventSpecie_t fEventSpecie ;            //! event specie deduced from the GRP data
   ClassDef(AliQAChecker, 1)  // class for running generation, simulation and digitization
 };
index 07a23c8..cfaf980 100644 (file)
@@ -36,7 +36,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliQACheckerBase.h"
 #include "AliQADataMaker.h"
@@ -54,22 +54,22 @@ AliQACheckerBase::AliQACheckerBase(const char * name, const char * title) :
   fUpTestValue(0x0)
 {
   // ctor
-  fLowTestValue = new Float_t[AliQA::kNBIT] ; 
-  fUpTestValue  = new Float_t[AliQA::kNBIT] ; 
-  fLowTestValue[AliQA::kINFO]    =  0.5   ; 
-  fUpTestValue[AliQA::kINFO]     = 1.0 ; 
-  fLowTestValue[AliQA::kWARNING] =  0.002 ; 
-  fUpTestValue[AliQA::kWARNING]  = 0.5 ; 
-  fLowTestValue[AliQA::kERROR]   =  0.0   ; 
-  fUpTestValue[AliQA::kERROR]    = 0.002 ; 
-  fLowTestValue[AliQA::kFATAL]   = -1.0   ; 
-  fUpTestValue[AliQA::kFATAL]    = 0.0 ; 
+  fLowTestValue = new Float_t[AliQAv1::kNBIT] ; 
+  fUpTestValue  = new Float_t[AliQAv1::kNBIT] ; 
+  fLowTestValue[AliQAv1::kINFO]    =  0.5   ; 
+  fUpTestValue[AliQAv1::kINFO]     = 1.0 ; 
+  fLowTestValue[AliQAv1::kWARNING] =  0.002 ; 
+  fUpTestValue[AliQAv1::kWARNING]  = 0.5 ; 
+  fLowTestValue[AliQAv1::kERROR]   =  0.0   ; 
+  fUpTestValue[AliQAv1::kERROR]    = 0.002 ; 
+  fLowTestValue[AliQAv1::kFATAL]   = -1.0   ; 
+  fUpTestValue[AliQAv1::kFATAL]    = 0.0 ; 
   
   AliInfo("Default setting is:") ;
-  printf( "                      INFO    -> %1.5f <  value <  %1.5f \n", fLowTestValue[AliQA::kINFO], fUpTestValue[AliQA::kINFO]) ; 
-  printf( "                      WARNING -> %1.5f <  value <= %1.5f \n", fLowTestValue[AliQA::kWARNING], fUpTestValue[AliQA::kWARNING]) ; 
-  printf( "                      ERROR   -> %1.5f <  value <= %1.5f \n", fLowTestValue[AliQA::kERROR], fUpTestValue[AliQA::kERROR]) ; 
-  printf( "                      FATAL   -> %1.5f <= value <  %1.5f \n", fLowTestValue[AliQA::kFATAL], fUpTestValue[AliQA::kFATAL]) ; 
+  printf( "                      INFO    -> %1.5f <  value <  %1.5f \n", fLowTestValue[AliQAv1::kINFO], fUpTestValue[AliQAv1::kINFO]) ; 
+  printf( "                      WARNING -> %1.5f <  value <= %1.5f \n", fLowTestValue[AliQAv1::kWARNING], fUpTestValue[AliQAv1::kWARNING]) ; 
+  printf( "                      ERROR   -> %1.5f <  value <= %1.5f \n", fLowTestValue[AliQAv1::kERROR], fUpTestValue[AliQAv1::kERROR]) ; 
+  printf( "                      FATAL   -> %1.5f <= value <  %1.5f \n", fLowTestValue[AliQAv1::kFATAL], fUpTestValue[AliQAv1::kFATAL]) ; 
   
 }
 
@@ -83,7 +83,7 @@ AliQACheckerBase::AliQACheckerBase(const AliQACheckerBase& qac) :
   fUpTestValue(qac.fLowTestValue)
 {
   //copy ctor
-  for (Int_t index = 0 ; index < AliQA::kNBIT ; index++) {
+  for (Int_t index = 0 ; index < AliQAv1::kNBIT ; index++) {
     fLowTestValue[index]  = qac.fLowTestValue[index] ; 
     fUpTestValue[index] = qac.fUpTestValue[index] ; 
   }
@@ -107,7 +107,7 @@ AliQACheckerBase::~AliQACheckerBase()
 }
 
 //____________________________________________________________________________
-Double_t * AliQACheckerBase::Check(AliQA::ALITASK_t /*index*/) 
+Double_t * AliQACheckerBase::Check(AliQAv1::ALITASK_t /*index*/) 
 {
   // Performs a basic checking
   // Compares all the histograms stored in the directory
@@ -118,7 +118,7 @@ Double_t * AliQACheckerBase::Check(AliQA::ALITASK_t /*index*/)
 
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
     test[specie] = 1.0 ; 
-    if ( !AliQA::Instance()->IsEventSpecieSet(specie) ) 
+    if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) 
       continue ; 
     if (!fDataSubDir) {
       test[specie] = 0. ; // nothing to check
@@ -158,7 +158,7 @@ Double_t * AliQACheckerBase::Check(AliQA::ALITASK_t /*index*/)
 }  
 
 //____________________________________________________________________________
-Double_t * AliQACheckerBase::Check(AliQA::ALITASK_t /*index*/, TObjArray ** list) 
+Double_t * AliQACheckerBase::Check(AliQAv1::ALITASK_t /*index*/, TObjArray ** list) 
 {
   // Performs a basic checking
   // Compares all the histograms in the list
@@ -168,7 +168,7 @@ Double_t * AliQACheckerBase::Check(AliQA::ALITASK_t /*index*/, TObjArray ** list
 
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
     test[specie] = 1.0 ; 
-    if ( !AliQA::Instance()->IsEventSpecieSet(specie) ) 
+    if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) 
       continue ; 
     if (list[specie]->GetEntries() == 0)  
       test[specie] = 0. ; // nothing to check
@@ -181,7 +181,7 @@ Double_t * AliQACheckerBase::Check(AliQA::ALITASK_t /*index*/, TObjArray ** list
         count[specie] = 0 ; 
         while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
           if ( hdata) { 
-            if ( hdata->TestBit(AliQA::GetExpertBit()) )  // does not perform the test for expert data
+            if ( hdata->TestBit(AliQAv1::GetExpertBit()) )  // does not perform the test for expert data
               continue ; 
             TH1 * href = NULL ; 
             if (fRefSubDir) 
@@ -234,9 +234,9 @@ Double_t AliQACheckerBase::DiffK(const TH1 * href, const TH1 * hin) const
 }
 
 //____________________________________________________________________________
-void AliQACheckerBase::Run(AliQA::ALITASK_t index, TObjArray ** list) 
+void AliQACheckerBase::Run(AliQAv1::ALITASK_t index, TObjArray ** list) 
 { 
-       AliDebug(1, Form("Processing %s", AliQA::GetAliTaskName(index))) ; 
+       AliDebug(1, Form("Processing %s", AliQAv1::GetAliTaskName(index))) ; 
   
        Double_t * rv = NULL ;
   if ( !list) 
@@ -245,7 +245,7 @@ void AliQACheckerBase::Run(AliQA::ALITASK_t index, TObjArray ** list)
     rv = Check(index, list) ;
        SetQA(index, rv) ;      
        
-  AliDebug(1, Form("Test result of %s", AliQA::GetAliTaskName(index))) ;
+  AliDebug(1, Form("Test result of %s", AliQAv1::GetAliTaskName(index))) ;
        
   if (rv) 
     delete [] rv ; 
@@ -256,51 +256,51 @@ void AliQACheckerBase::Run(AliQA::ALITASK_t index, TObjArray ** list)
 void AliQACheckerBase::Finish() const 
 {
        // wrap up and save QA in proper file
-       AliQA * qa = AliQA::Instance() ; 
+       AliQAv1 * qa = AliQAv1::Instance() ; 
        qa->Show() ;
-       AliQA::GetQAResultFile()->cd() ; 
+       AliQAv1::GetQAResultFile()->cd() ; 
        qa->Write(qa->GetName(), kWriteDelete) ;   
-       AliQA::GetQAResultFile()->Close() ; 
+       AliQAv1::GetQAResultFile()->Close() ; 
 }
 
 //____________________________________________________________________________
 void AliQACheckerBase::SetHiLo(Float_t * hiValue, Float_t * lowValue) 
 {
   AliInfo("Previous setting was:") ;
-  printf( "                      INFO    -> %1.5f <  value <  %1.5f \n", fLowTestValue[AliQA::kINFO], fUpTestValue[AliQA::kINFO]) ; 
-  printf( "                      WARNING -> %1.5f <  value <= %1.5f \n", fLowTestValue[AliQA::kWARNING], fUpTestValue[AliQA::kWARNING]) ; 
-  printf( "                      ERROR   -> %1.5f <  value <= %1.5f \n", fLowTestValue[AliQA::kERROR], fUpTestValue[AliQA::kERROR]) ; 
-  printf( "                      FATAL   -> %1.5f <= value <  %1.5f \n", fLowTestValue[AliQA::kFATAL], fUpTestValue[AliQA::kFATAL]) ; 
+  printf( "                      INFO    -> %1.5f <  value <  %1.5f \n", fLowTestValue[AliQAv1::kINFO], fUpTestValue[AliQAv1::kINFO]) ; 
+  printf( "                      WARNING -> %1.5f <  value <= %1.5f \n", fLowTestValue[AliQAv1::kWARNING], fUpTestValue[AliQAv1::kWARNING]) ; 
+  printf( "                      ERROR   -> %1.5f <  value <= %1.5f \n", fLowTestValue[AliQAv1::kERROR], fUpTestValue[AliQAv1::kERROR]) ; 
+  printf( "                      FATAL   -> %1.5f <= value <  %1.5f \n", fLowTestValue[AliQAv1::kFATAL], fUpTestValue[AliQAv1::kFATAL]) ; 
   
-  for (Int_t index = 0 ; index < AliQA::kNBIT ; index++) {
+  for (Int_t index = 0 ; index < AliQAv1::kNBIT ; index++) {
     fLowTestValue[index]  = lowValue[index] ; 
     fUpTestValue[index] = hiValue[index] ; 
   }
   AliInfo("Current setting is:") ;
-  printf( "                      INFO    -> %1.5f <  value <  %1.5f \n", fLowTestValue[AliQA::kINFO], fUpTestValue[AliQA::kINFO]) ; 
-  printf( "                      WARNING -> %1.5f <  value <= %1.5f \n", fLowTestValue[AliQA::kWARNING], fUpTestValue[AliQA::kWARNING]) ; 
-  printf( "                      ERROR   -> %1.5f <  value <= %1.5f \n", fLowTestValue[AliQA::kERROR], fUpTestValue[AliQA::kERROR]) ; 
-  printf( "                      FATAL   -> %1.5f <= value <  %1.5f \n", fLowTestValue[AliQA::kFATAL], fUpTestValue[AliQA::kFATAL]) ; 
+  printf( "                      INFO    -> %1.5f <  value <  %1.5f \n", fLowTestValue[AliQAv1::kINFO], fUpTestValue[AliQAv1::kINFO]) ; 
+  printf( "                      WARNING -> %1.5f <  value <= %1.5f \n", fLowTestValue[AliQAv1::kWARNING], fUpTestValue[AliQAv1::kWARNING]) ; 
+  printf( "                      ERROR   -> %1.5f <  value <= %1.5f \n", fLowTestValue[AliQAv1::kERROR], fUpTestValue[AliQAv1::kERROR]) ; 
+  printf( "                      FATAL   -> %1.5f <= value <  %1.5f \n", fLowTestValue[AliQAv1::kFATAL], fUpTestValue[AliQAv1::kFATAL]) ; 
 }
 
 //____________________________________________________________________________
-void AliQACheckerBase::SetQA(AliQA::ALITASK_t index, Double_t * value) const
+void AliQACheckerBase::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
 {
        // sets the QA according the return value of the Check
 
-  AliQA * qa = AliQA::Instance(index) ;
+  AliQAv1 * qa = AliQAv1::Instance(index) ;
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
     if (  value == NULL ) { // No checker is implemented, set all QA to Fatal
-      qa->Set(AliQA::kFATAL, specie) ; 
+      qa->Set(AliQAv1::kFATAL, specie) ; 
     } else {
-      if ( value[specie] >= fLowTestValue[AliQA::kFATAL] && value[specie] < fUpTestValue[AliQA::kFATAL] ) 
-        qa->Set(AliQA::kFATAL, specie) ; 
-      else if ( value[specie] > fLowTestValue[AliQA::kERROR] && value[specie] <= fUpTestValue[AliQA::kERROR]  )
-        qa->Set(AliQA::kERROR, specie) ; 
-      else if ( value[specie] > fLowTestValue[AliQA::kWARNING] && value[specie] <= fUpTestValue[AliQA::kWARNING]  )
-        qa->Set(AliQA::kWARNING, specie) ;
-      else if ( value[specie] > fLowTestValue[AliQA::kINFO] && value[specie] <= fUpTestValue[AliQA::kINFO] ) 
-        qa->Set(AliQA::kINFO, specie) ;        
+      if ( value[specie] >= fLowTestValue[AliQAv1::kFATAL] && value[specie] < fUpTestValue[AliQAv1::kFATAL] ) 
+        qa->Set(AliQAv1::kFATAL, specie) ; 
+      else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] && value[specie] <= fUpTestValue[AliQAv1::kERROR]  )
+        qa->Set(AliQAv1::kERROR, specie) ; 
+      else if ( value[specie] > fLowTestValue[AliQAv1::kWARNING] && value[specie] <= fUpTestValue[AliQAv1::kWARNING]  )
+        qa->Set(AliQAv1::kWARNING, specie) ;
+      else if ( value[specie] > fLowTestValue[AliQAv1::kINFO] && value[specie] <= fUpTestValue[AliQAv1::kINFO] ) 
+        qa->Set(AliQAv1::kINFO, specie) ;      
     }
   }
 }
index 74686ea..a2df5f0 100644 (file)
@@ -15,7 +15,7 @@
 
 // --- ROOT system ---
 #include <TNamed.h>
-#include "AliQA.h"
+#include "AliQAv1.h"
 class TFile ; 
 class TH1 ; 
 class TObjArray ; 
@@ -34,20 +34,20 @@ public:
   AliQACheckerBase& operator = (const AliQACheckerBase& qac) ;
   virtual ~AliQACheckerBase() ; // dtor
 
-  virtual void   Init(const AliQA::DETECTORINDEX_t det)   { AliQA::Instance(det) ; }
-  void           Run(AliQA::ALITASK_t tsk, TObjArray ** list = NULL); 
-  void           Run(AliQA::ALITASK_t /*tsk*/, TNtupleD ** /*nt*/) {;} 
+  virtual void   Init(const AliQAv1::DETECTORINDEX_t det)   { AliQAv1::Instance(det) ; }
+  void           Run(AliQAv1::ALITASK_t tsk, TObjArray ** list = NULL); 
+  void           Run(AliQAv1::ALITASK_t /*tsk*/, TNtupleD ** /*nt*/) {;} 
   void           SetHiLo(Float_t * hiValue, Float_t * lowValue) ; 
   void           SetRefandData(TDirectory * ref, TObjArray ** refOCDB, TDirectory * data=NULL) { fRefSubDir = ref ;  fRefOCDBSubDir = refOCDB, fDataSubDir = data ; }
 
 protected:
-  virtual      Double_t * Check(AliQA::ALITASK_t index) ;
-  virtual      Double_t * Check(AliQA::ALITASK_t, TObjArray **) ; 
+  virtual      Double_t * Check(AliQAv1::ALITASK_t index) ;
+  virtual      Double_t * Check(AliQAv1::ALITASK_t, TObjArray **) ; 
 
   Double_t     DiffC(const TH1 * href, const TH1 * hin) const ;   
   Double_t     DiffK(const TH1 * href, const TH1 * hin) const ;   
   void         Finish() const ; 
-  virtual void SetQA(AliQA::ALITASK_t index, Double_t * value) const ; 
+  virtual void SetQA(AliQAv1::ALITASK_t index, Double_t * value) 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
index 97e145b..41a6a56 100644 (file)
@@ -105,7 +105,7 @@ Int_t AliQADataMaker::Add2List(TH1 * hist, const Int_t index, TObjArray ** list,
                AliError("Max number of authorized QA objects is 10000") ; 
   } else {    
     if (expert) 
-      hist->SetBit(AliQA::GetExpertBit()) ; 
+      hist->SetBit(AliQAv1::GetExpertBit()) ; 
                TH1 * histClone[AliRecoParam::kNSpecies] ; 
     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
       histClone[specie] = CloneMe(hist, specie) ; 
@@ -131,23 +131,23 @@ TH1 *  AliQADataMaker::CloneMe(TH1 * hist, Int_t specie) const
   // clones a histogram 
   char * name = Form("%s_%s", AliRecoParam::GetEventSpecieName(specie), hist->GetName()) ;
   TH1 * hClone = dynamic_cast<TH1 *>(hist->Clone(name)) ; 
-  if ( hist->TestBit(AliQA::GetExpertBit()) )
-       hClone->SetBit(AliQA::GetExpertBit()) ; 
+  if ( hist->TestBit(AliQAv1::GetExpertBit()) )
+       hClone->SetBit(AliQAv1::GetExpertBit()) ; 
   return hClone ; 
 }
 
 //____________________________________________________________________________
-void AliQADataMaker::DefaultEndOfDetectorCycle(AliQA::TASKINDEX_t task) 
+void AliQADataMaker::DefaultEndOfDetectorCycle(AliQAv1::TASKINDEX_t task) 
 {
        // this method must be oveloaded by detectors
        // sets the QA result to Fatal
-       AliQA::Instance(AliQA::GetDetIndex(GetName())) ;
-       AliQA * qa = AliQA::Instance(task) ;
+       AliQAv1::Instance(AliQAv1::GetDetIndex(GetName())) ;
+       AliQAv1 * qa = AliQAv1::Instance(task) ;
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
-    qa->Set(AliQA::kFATAL, specie) ; 
-       AliQA::GetQAResultFile()->cd() ; 
-       qa->Write(AliQA::GetQAName(), kWriteDelete) ;   
-       AliQA::GetQAResultFile()->Close() ; 
+    qa->Set(AliQAv1::kFATAL, specie) ; 
+       AliQAv1::GetQAResultFile()->cd() ; 
+       qa->Write(AliQAv1::GetQAName(), kWriteDelete) ;   
+       AliQAv1::GetQAResultFile()->Close() ; 
 }
 
 //____________________________________________________________________________ 
index 57a6336..1c25652 100644 (file)
@@ -30,7 +30,7 @@ class AliDetectorRecoParam;
 // --- Standard library ---
 
 // --- AliRoot header files ---
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliRecoParam.h" 
 
 class AliQADataMaker: public TNamed {
@@ -47,9 +47,9 @@ public:
        virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE)       = 0 ; 
        virtual Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t saveForCorr = kFALSE)            = 0 ; 
        virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE)         = 0 ; 
-       virtual void        Exec(AliQA::TASKINDEX_t, TObject * data)                                       = 0 ;
+       virtual void        Exec(AliQAv1::TASKINDEX_t, TObject * data)                                       = 0 ;
        virtual void        EndOfCycle()                                           = 0 ;
-       virtual void        EndOfCycle(AliQA::TASKINDEX_t        )                 = 0 ;
+       virtual void        EndOfCycle(AliQAv1::TASKINDEX_t        )                 = 0 ;
        void                Finish() const ; 
        virtual TH1 *       GetDigitsData(const Int_t index)                       = 0 ; 
        virtual TH1 *       GetESDsData(const Int_t index)                         = 0 ; 
@@ -60,14 +60,14 @@ public:
        const char *        GetDetectorDirName() const { return fDetectorDirName.Data() ; }
   TList *             GetParameterList() const { return fParameterList[AliRecoParam::AConvert(fEventSpecie)] ; }
        Int_t               Increment() { return ++fCycleCounter ; } 
-       virtual TObjArray** Init(AliQA::TASKINDEX_t, Int_t cycles = -1)                               = 0 ;
-       virtual void        Init(AliQA::TASKINDEX_t, TObjArray ** list, Int_t run, Int_t cycles = -1) = 0 ;
+       virtual TObjArray** Init(AliQAv1::TASKINDEX_t, Int_t cycles = -1)                               = 0 ;
+       virtual void        Init(AliQAv1::TASKINDEX_t, TObjArray ** list, Int_t run, Int_t cycles = -1) = 0 ;
        Bool_t              IsCycleDone() const { return fCycleCounter > fCycle ? kTRUE : kFALSE ; }
        void                Reset() { fCycleCounter = 0 ; }
        void                SetCycle(Int_t nevts) { fCycle = nevts ; } 
   void                SetWriteExpert() { fWriteExpert = kTRUE ; }
        virtual void        StartOfCycle(Int_t run = -1)                                                 = 0 ;
-       virtual void        StartOfCycle(AliQA::TASKINDEX_t, Int_t run, const Bool_t sameCycle = kFALSE) = 0 ;
+       virtual void        StartOfCycle(AliQAv1::TASKINDEX_t, Int_t run, const Bool_t sameCycle = kFALSE) = 0 ;
   void                UnSetWriteExpert() { fWriteExpert = kFALSE ; }
   Bool_t              WriteExpert() { return fWriteExpert ; }
   void                SetEventSpecie(AliRecoParam::EventSpecie_t es) { fEventSpecie = es ; }
@@ -78,8 +78,8 @@ protected:
 
        Int_t          Add2List(TH1 * hist, const Int_t index, TObjArray ** list, const Bool_t expert = kFALSE, const Bool_t saveForCorr = kFALSE) ;
   TH1 *          CloneMe(TH1 * hist, Int_t specie) const ; 
-       virtual void   DefaultEndOfDetectorCycle(AliQA::TASKINDEX_t task ) ; 
-       virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list ) = 0 ; 
+       virtual void   DefaultEndOfDetectorCycle(AliQAv1::TASKINDEX_t task ) ; 
+       virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list ) = 0 ; 
        TObject *      GetData(TObjArray ** list, const Int_t index) ;
        virtual void   InitDigits()        = 0 ; 
        virtual void   InitESDs()          = 0 ; 
index 8b70074..f6d0522 100644 (file)
@@ -118,24 +118,24 @@ AliQADataMakerRec& AliQADataMakerRec::operator = (const AliQADataMakerRec& qadm
 void AliQADataMakerRec::EndOfCycle() 
 {
   // Finishes a cycle of QA for all the tasks
-  EndOfCycle(AliQA::kRAWS) ; 
-  EndOfCycle(AliQA::kRECPOINTS) ; 
-  EndOfCycle(AliQA::kESDS) ; 
+  EndOfCycle(AliQAv1::kRAWS) ; 
+  EndOfCycle(AliQAv1::kRECPOINTS) ; 
+  EndOfCycle(AliQAv1::kESDS) ; 
   ResetCycle() ; 
 }
 
 //____________________________________________________________________________
-void AliQADataMakerRec::EndOfCycle(AliQA::TASKINDEX_t task) 
+void AliQADataMakerRec::EndOfCycle(AliQAv1::TASKINDEX_t task) 
 {
        // Finishes a cycle of QA 
        
        TObjArray ** list = NULL ; 
        
-       if ( task == AliQA::kRAWS )     
+       if ( task == AliQAv1::kRAWS )     
                list = fRawsQAList ; 
-       else if ( task == AliQA::kRECPOINTS ) 
+       else if ( task == AliQAv1::kRECPOINTS ) 
                list = fRecPointsQAList ; 
-       else if ( task == AliQA::kESDS )
+       else if ( task == AliQAv1::kESDS )
                list = fESDsQAList ; 
 
  
@@ -145,7 +145,7 @@ void AliQADataMakerRec::EndOfCycle(AliQA::TASKINDEX_t task)
        EndOfDetectorCycle(task, list) ;
        TDirectory * subDir = NULL ;
        if (fDetectorDir) 
-               subDir = fDetectorDir->GetDirectory(AliQA::GetTaskName(task)) ; 
+               subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ; 
        if ( subDir ) {
                subDir->cd() ; 
     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
@@ -156,16 +156,16 @@ void AliQADataMakerRec::EndOfCycle(AliQA::TASKINDEX_t task)
           TIter next(list[specie]) ; 
           TObject * obj ; 
           while( (obj = next()) ) {
-            if (!obj->TestBit(AliQA::GetExpertBit()))
+            if (!obj->TestBit(AliQAv1::GetExpertBit()))
               obj->Write() ;
           }
           if (WriteExpert()) {
-            TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQA::GetExpert()) ; 
+            TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ; 
             if ( expertDir ) { // Write only if requested
               expertDir->cd() ;
               next.Reset() ; 
               while( (obj = next()) ) {
-                if (!obj->TestBit(AliQA::GetExpertBit()))
+                if (!obj->TestBit(AliQAv1::GetExpertBit()))
                   continue ; 
                 obj->Write() ;
               }      
@@ -174,7 +174,7 @@ void AliQADataMakerRec::EndOfCycle(AliQA::TASKINDEX_t task)
         }
         if ( !fCorrNt )
           continue ; 
-        if (fCorrNt[specie] && AliQA::GetDetIndex(GetName()) == AliQA::kCORR) {
+        if (fCorrNt[specie] && AliQAv1::GetDetIndex(GetName()) == AliQAv1::kCORR) {
           eventSpecieDir->cd() ; 
           fCorrNt[specie]->Write() ; 
         }
@@ -185,18 +185,18 @@ void AliQADataMakerRec::EndOfCycle(AliQA::TASKINDEX_t task)
 }
  
 //____________________________________________________________________________
-void AliQADataMakerRec::Exec(AliQA::TASKINDEX_t task, TObject * data) 
+void AliQADataMakerRec::Exec(AliQAv1::TASKINDEX_t task, TObject * data) 
 { 
   // creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs)
        
-       if ( task == AliQA::kRAWS ) {
+       if ( task == AliQAv1::kRAWS ) {
                AliDebug(1, "Processing Raws QA") ; 
                AliRawReader * rawReader = dynamic_cast<AliRawReader *>(data) ; 
                if (rawReader) 
                        MakeRaws(rawReader) ;
                else
                AliInfo("Raw data are not processed") ;     
-       } else if ( task == AliQA::kRECPOINTS ) {
+       } else if ( task == AliQAv1::kRECPOINTS ) {
                AliDebug(1, "Processing RecPoints QA") ; 
                TTree * tree = dynamic_cast<TTree *>(data) ; 
                if (tree) {
@@ -204,7 +204,7 @@ void AliQADataMakerRec::Exec(AliQA::TASKINDEX_t task, TObject * data)
                } else {
                        AliWarning("data are not a TTree") ; 
                }
-       } else if ( task == AliQA::kESDS ) {
+       } else if ( task == AliQAv1::kESDS ) {
                AliDebug(1, "Processing ESDs QA") ; 
                AliESDEvent * esd = dynamic_cast<AliESDEvent *>(data) ; 
                if (esd) 
@@ -215,7 +215,7 @@ void AliQADataMakerRec::Exec(AliQA::TASKINDEX_t task, TObject * data)
 }
 
 //____________________________________________________________________________ 
-TObjArray **  AliQADataMakerRec::Init(AliQA::TASKINDEX_t task, Int_t cycles)
+TObjArray **  AliQADataMakerRec::Init(AliQAv1::TASKINDEX_t task, Int_t cycles)
 {
   // general intialisation
   InitRecoParams() ;
@@ -224,32 +224,32 @@ TObjArray **  AliQADataMakerRec::Init(AliQA::TASKINDEX_t task, Int_t cycles)
        if (cycles > 0)
                SetCycle(cycles) ;  
        
-       if ( task == AliQA::kRAWS ) {
+       if ( task == AliQAv1::kRAWS ) {
                if (! fRawsQAList ) { 
       fRawsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
       for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
         fRawsQAList[specie] = new TObjArray(100) ;      
-        fRawsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
+        fRawsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
       }
                        InitRaws() ;
                }
                rv = fRawsQAList ;
-       } else if ( task == AliQA::kRECPOINTS ) {
+       } else if ( task == AliQAv1::kRECPOINTS ) {
                if ( ! fRecPointsQAList ) {
       fRecPointsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
       for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
         fRecPointsQAList[specie] = new TObjArray(100) ; 
-        fRecPointsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
+        fRecPointsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
       }
       InitRecPoints() ;
                }
                rv = fRecPointsQAList ;
-       } else if ( task == AliQA::kESDS ) {
+       } else if ( task == AliQAv1::kESDS ) {
                if ( ! fESDsQAList ) {
       fESDsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
       for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
         fESDsQAList[specie] = new TObjArray(100) ;
-        fESDsQAList[specie]->SetName(Form("%s_%s", GetName(), AliQA::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
+        fESDsQAList[specie]->SetName(Form("%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
       }
                        InitESDs() ;
                }
@@ -259,7 +259,7 @@ TObjArray **  AliQADataMakerRec::Init(AliQA::TASKINDEX_t task, Int_t cycles)
 }
 
 //____________________________________________________________________________ 
-void AliQADataMakerRec::Init(AliQA::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles)
+void AliQADataMakerRec::Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles)
 {
   // Intialisation by passing the list of QA data booked elsewhere
   
@@ -268,11 +268,11 @@ void AliQADataMakerRec::Init(AliQA::TASKINDEX_t task, TObjArray ** list, Int_t r
        if (cycles > 0)
                SetCycle(cycles) ;  
        
-       if ( task == AliQA::kRAWS ) {
+       if ( task == AliQAv1::kRAWS ) {
                fRawsQAList = list ;     
-       } else if ( task == AliQA::kRECPOINTS ) {
+       } else if ( task == AliQAv1::kRECPOINTS ) {
                fRecPointsQAList = list ; 
-       } else if ( task == AliQA::kESDS ) {
+       } else if ( task == AliQAv1::kESDS ) {
                fESDsQAList = list ; 
        }
 }
@@ -318,14 +318,14 @@ void AliQADataMakerRec::StartOfCycle(Int_t run)
 {
   // Finishes a cycle of QA for all the tasks
   Bool_t samecycle = kFALSE ; 
-  StartOfCycle(AliQA::kRAWS,      run, samecycle) ;
+  StartOfCycle(AliQAv1::kRAWS,      run, samecycle) ;
   samecycle = kTRUE ; 
-  StartOfCycle(AliQA::kRECPOINTS, run, samecycle) ; 
-  StartOfCycle(AliQA::kESDS,      run, samecycle) ; 
+  StartOfCycle(AliQAv1::kRECPOINTS, run, samecycle) ; 
+  StartOfCycle(AliQAv1::kESDS,      run, samecycle) ; 
 }
 
 //____________________________________________________________________________
-void AliQADataMakerRec::StartOfCycle(AliQA::TASKINDEX_t task, Int_t run, const Bool_t sameCycle) 
+void AliQADataMakerRec::StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle) 
 { 
   // Finishes a cycle of QA data acquistion
   if ( run > 0 ) 
@@ -334,26 +334,26 @@ void AliQADataMakerRec::StartOfCycle(AliQA::TASKINDEX_t task, Int_t run, const B
                ResetCycle() ;
                if (fOutput) 
                        fOutput->Close() ; 
-               fOutput = AliQA::GetQADataFile(GetName(), fRun) ;       
+               fOutput = AliQAv1::GetQADataFile(GetName(), fRun) ;     
        }       
        AliInfo(Form(" Run %d Cycle %d task %s file %s", 
-                                fRun, fCurrentCycle, AliQA::GetTaskName(task).Data(), fOutput->GetName() )) ;
+                                fRun, fCurrentCycle, AliQAv1::GetTaskName(task).Data(), fOutput->GetName() )) ;
 
        fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ; 
        if (!fDetectorDir)
                fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ; 
 
-       TDirectory * subDir = fDetectorDir->GetDirectory(AliQA::GetTaskName(task)) ; 
+       TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ; 
        if (!subDir)
-               subDir = fDetectorDir->mkdir(AliQA::GetTaskName(task)) ;  
+               subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;  
   
   for ( Int_t specie = AliRecoParam::kDefault ; specie < AliRecoParam::kNSpecies ; specie++ ) {
     TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(specie)) ; 
     if (!eventSpecieDir) 
       eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(specie)) ; 
-    TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQA::GetExpert()) ; 
+    TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ; 
     if (!expertDir)
-      expertDir = eventSpecieDir->mkdir(AliQA::GetExpert()) ; 
+      expertDir = eventSpecieDir->mkdir(AliQAv1::GetExpert()) ; 
   } 
        StartOfDetectorCycle() ; 
 }
index de2cffa..0af5701 100644 (file)
@@ -20,7 +20,7 @@ class TNtupleD ;
 // --- AliRoot header files ---
 class AliDetectorRecoParam ;
 #include "AliQADataMaker.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 
 class AliQADataMakerRec: public AliQADataMaker {
   
@@ -37,20 +37,20 @@ public:
        virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE)  { return Add2List(hist, index, fRecPointsQAList, expert) ; }
        virtual Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t saveForCorr = kFALSE)  { return Add2List(hist, index, fRawsQAList, expert, saveForCorr) ; }
        virtual Int_t Add2SDigitsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/)   { return -1 ; } 
-       virtual void        Exec(AliQA::TASKINDEX_t task, TObject * data) ;
+       virtual void        Exec(AliQAv1::TASKINDEX_t task, TObject * data) ;
        virtual void        EndOfCycle() ;
-       virtual void        EndOfCycle(AliQA::TASKINDEX_t task) ;
-       virtual void        EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** ) {AliInfo("To be implemented by detectors");} 
+       virtual void        EndOfCycle(AliQAv1::TASKINDEX_t task) ;
+       virtual void        EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** ) {AliInfo("To be implemented by detectors");} 
        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_t task, Int_t cycles = -1) ;
-       virtual void        Init(AliQA::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles = -1) ;
+       virtual TObjArray** Init(AliQAv1::TASKINDEX_t task, Int_t cycles = -1) ;
+       virtual void        Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles = -1) ;
        virtual void        StartOfCycle(Int_t run = -1) ;
-       virtual void        StartOfCycle(AliQA::TASKINDEX_t task, Int_t run, const Bool_t sameCycle = kFALSE) ;
+       virtual void        StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle = kFALSE) ;
 
        virtual void        SetRecoParam(const AliDetectorRecoParam *param) { fRecoParam = param; }
 
index 45b516e..2dd293f 100644 (file)
@@ -98,23 +98,23 @@ AliQADataMakerSim& AliQADataMakerSim::operator = (const AliQADataMakerSim& qadm
 void AliQADataMakerSim::EndOfCycle() 
 { 
   // Finishes a cycle of QA for all tasks
-  EndOfCycle(AliQA::kHITS) ; 
-  EndOfCycle(AliQA::kSDIGITS) ; 
-  EndOfCycle(AliQA::kDIGITS) ;
+  EndOfCycle(AliQAv1::kHITS) ; 
+  EndOfCycle(AliQAv1::kSDIGITS) ; 
+  EndOfCycle(AliQAv1::kDIGITS) ;
   ResetCycle() ; 
 }
 
 //____________________________________________________________________________
-void AliQADataMakerSim::EndOfCycle(AliQA::TASKINDEX_t task) 
+void AliQADataMakerSim::EndOfCycle(AliQAv1::TASKINDEX_t task) 
 { 
   // Finishes a cycle of QA data acquistion
        TObjArray ** list = NULL ; 
        
-       if ( task == AliQA::kHITS ) 
+       if ( task == AliQAv1::kHITS ) 
                list = fHitsQAList ; 
-       else if ( task == AliQA::kSDIGITS )
+       else if ( task == AliQAv1::kSDIGITS )
                list = fSDigitsQAList ; 
-       else if ( task == AliQA::kDIGITS ) 
+       else if ( task == AliQAv1::kDIGITS ) 
                list = fDigitsQAList ; 
   
   if ( ! list ) 
@@ -122,7 +122,7 @@ void AliQADataMakerSim::EndOfCycle(AliQA::TASKINDEX_t task)
        EndOfDetectorCycle(task, list) ; 
   TDirectory * subDir = NULL ;
        if (fDetectorDir) 
-    subDir = fDetectorDir->GetDirectory(AliQA::GetTaskName(task)) ; 
+    subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ; 
        if (subDir) { 
                subDir->cd() ; 
     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
@@ -132,16 +132,16 @@ void AliQADataMakerSim::EndOfCycle(AliQA::TASKINDEX_t task)
         TIter next(list[specie]) ; 
         TObject * obj ; 
         while ( (obj = next()) )  {
-          if (!obj->TestBit(AliQA::GetExpertBit()))
+          if (!obj->TestBit(AliQAv1::GetExpertBit()))
             obj->Write() ;
         }
         if (WriteExpert()) {
-          TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQA::GetExpert()) ; 
+          TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ; 
           if ( expertDir ) {
             expertDir->cd() ;
             next.Reset() ; 
             while ( (obj = next()) ) {
-              if (!obj->TestBit(AliQA::GetExpertBit()))
+              if (!obj->TestBit(AliQAv1::GetExpertBit()))
                 continue ; 
             obj->Write() ;
             }      
@@ -155,11 +155,11 @@ void AliQADataMakerSim::EndOfCycle(AliQA::TASKINDEX_t task)
 }
  
 //____________________________________________________________________________
-void AliQADataMakerSim::Exec(AliQA::TASKINDEX_t task, TObject * data) 
+void AliQADataMakerSim::Exec(AliQAv1::TASKINDEX_t task, TObject * data) 
 { 
   // creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs)
     
-       if ( task == AliQA::kHITS ) {  
+       if ( task == AliQAv1::kHITS ) {  
                AliDebug(1, "Processing Hits QA") ; 
                TClonesArray * arr = dynamic_cast<TClonesArray *>(data) ; 
                if (arr) { 
@@ -172,7 +172,7 @@ void AliQADataMakerSim::Exec(AliQA::TASKINDEX_t task, TObject * data)
                                AliWarning("data are neither a TClonesArray nor a TTree") ; 
                        }
                }
-       } else if ( task == AliQA::kSDIGITS ) {
+       } else if ( task == AliQAv1::kSDIGITS ) {
                AliDebug(1, "Processing SDigits QA") ; 
                TClonesArray * arr = dynamic_cast<TClonesArray *>(data) ; 
                if (arr) { 
@@ -185,7 +185,7 @@ void AliQADataMakerSim::Exec(AliQA::TASKINDEX_t task, TObject * data)
                                AliWarning("data are neither a TClonesArray nor a TTree") ; 
                        }
                }
-       } else if ( task == AliQA::kDIGITS ) {
+       } else if ( task == AliQAv1::kDIGITS ) {
                AliDebug(1, "Processing Digits QA") ; 
                TClonesArray * arr = dynamic_cast<TClonesArray *>(data) ; 
                if (arr) { 
@@ -202,39 +202,39 @@ void AliQADataMakerSim::Exec(AliQA::TASKINDEX_t task, TObject * data)
 }
 
 //____________________________________________________________________________ 
-TObjArray **  AliQADataMakerSim::Init(AliQA::TASKINDEX_t task, Int_t cycles)
+TObjArray **  AliQADataMakerSim::Init(AliQAv1::TASKINDEX_t task, Int_t cycles)
 {
   // general intialisation
        
        if (cycles > 0)
                SetCycle(cycles) ;  
        TObjArray ** rv = NULL ; 
-       if ( task == AliQA::kHITS ) {
+       if ( task == AliQAv1::kHITS ) {
                if ( ! fHitsQAList ) {
       fHitsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
       for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
         fHitsQAList[specie] = new TObjArray(100) ;      
-        fHitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
+        fHitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
       }
                        InitHits() ;
                }
                rv = fHitsQAList ;
-       } else if ( task == AliQA::kSDIGITS ) {
+       } else if ( task == AliQAv1::kSDIGITS ) {
                if ( ! fSDigitsQAList ) {
       fSDigitsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
       for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
         fSDigitsQAList[specie] = new TObjArray(100) ; 
-        fSDigitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
+        fSDigitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
       }
       InitSDigits() ;
                }
                rv = fSDigitsQAList ;
-   } else if ( task == AliQA::kDIGITS ) {
+   } else if ( task == AliQAv1::kDIGITS ) {
           if ( ! fDigitsQAList ) {
        fDigitsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
        for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {    
          fDigitsQAList[specie] = new TObjArray(100) ;
-         fDigitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
+         fDigitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
        }
                   InitDigits() ;
           }
@@ -245,7 +245,7 @@ TObjArray **  AliQADataMakerSim::Init(AliQA::TASKINDEX_t task, Int_t cycles)
 }
 
 //____________________________________________________________________________ 
-void AliQADataMakerSim::Init(AliQA::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles)
+void AliQADataMakerSim::Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles)
 {
   // Intialisation by passing the list of QA data booked elsewhere
   
@@ -253,11 +253,11 @@ void AliQADataMakerSim::Init(AliQA::TASKINDEX_t task, TObjArray ** list, Int_t r
        if (cycles > 0)
                SetCycle(cycles) ;  
        
-       if ( task == AliQA::kHITS ) {
+       if ( task == AliQAv1::kHITS ) {
                fHitsQAList = list ;     
-       } else if ( task == AliQA::kSDIGITS) {
+       } else if ( task == AliQAv1::kSDIGITS) {
                fSDigitsQAList = list ; 
-       } else if ( task == AliQA::kDIGITS ) {
+       } else if ( task == AliQAv1::kDIGITS ) {
                fDigitsQAList = list ; 
        } 
 }
@@ -267,14 +267,14 @@ void AliQADataMakerSim::StartOfCycle(Int_t run)
 { 
   // Finishes a cycle of QA for all tasks
   Bool_t samecycle = kFALSE ; 
-  StartOfCycle(AliQA::kHITS,    run, samecycle) ;
+  StartOfCycle(AliQAv1::kHITS,    run, samecycle) ;
   samecycle = kTRUE ; 
-  StartOfCycle(AliQA::kSDIGITS, run, samecycle) ;
-  StartOfCycle(AliQA::kDIGITS,  run, samecycle) ;
+  StartOfCycle(AliQAv1::kSDIGITS, run, samecycle) ;
+  StartOfCycle(AliQAv1::kDIGITS,  run, samecycle) ;
 }
 
 //____________________________________________________________________________
-void AliQADataMakerSim::StartOfCycle(AliQA::TASKINDEX_t task, Int_t run, const Bool_t sameCycle) 
+void AliQADataMakerSim::StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle) 
 { 
   // Finishes a cycle of QA data acquistion
   if ( run > 0 ) 
@@ -283,27 +283,27 @@ void AliQADataMakerSim::StartOfCycle(AliQA::TASKINDEX_t task, Int_t run, const B
                ResetCycle() ;
        if (fOutput) 
                fOutput->Close() ; 
-       fOutput = AliQA::GetQADataFile(GetName(), fRun) ;       
+       fOutput = AliQAv1::GetQADataFile(GetName(), fRun) ;     
        }       
 
        AliInfo(Form(" Run %d Cycle %d task %s file %s", 
-                                fRun, fCurrentCycle, AliQA::GetTaskName(task).Data(), fOutput->GetName() )) ;
+                                fRun, fCurrentCycle, AliQAv1::GetTaskName(task).Data(), fOutput->GetName() )) ;
 
        fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ; 
        if (!fDetectorDir)
                fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ; 
 
-       TDirectory * subDir = fDetectorDir->GetDirectory(AliQA::GetTaskName(task)) ; 
+       TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ; 
        if (!subDir)
-               subDir = fDetectorDir->mkdir(AliQA::GetTaskName(task)) ;  
+               subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;  
   
   for ( Int_t index = AliRecoParam::kDefault ; index < AliRecoParam::kNSpecies ; index++ ) {
     TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(index)) ; 
     if (!eventSpecieDir) 
       eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(index)) ; 
-    TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQA::GetExpert()) ; 
+    TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ; 
     if (!expertDir) 
-      expertDir = eventSpecieDir->mkdir(AliQA::GetExpert()) ; 
+      expertDir = eventSpecieDir->mkdir(AliQAv1::GetExpert()) ; 
    }   
        StartOfDetectorCycle() ; 
 }
index 99bc0be..143688e 100644 (file)
@@ -34,20 +34,20 @@ public:
        virtual Int_t Add2RecPointsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/) { return -1 ; } 
        virtual Int_t Add2RawsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*saveForCorr = kFALSE*/)      { return -1 ; }  
        virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE)   { return Add2List(hist, index, fSDigitsQAList, expert) ; }
-       virtual void        Exec(AliQA::TASKINDEX_t task, TObject * data) ;
+       virtual void        Exec(AliQAv1::TASKINDEX_t task, TObject * data) ;
        virtual void        EndOfCycle() ;
-       virtual void        EndOfCycle(AliQA::TASKINDEX_t task) ;
-       virtual void        EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** ) {AliInfo("To be implemented by detectors");} 
+       virtual void        EndOfCycle(AliQAv1::TASKINDEX_t task) ;
+       virtual void        EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** ) {AliInfo("To be implemented by detectors");} 
        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_t task, Int_t cycles = -1) ;
-       virtual void        Init(AliQA::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles = -1) ;
+       virtual TObjArray** Init(AliQAv1::TASKINDEX_t task, Int_t cycles = -1) ;
+       virtual void        Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles = -1) ;
        virtual void        StartOfCycle(Int_t run = -1) ;
-       virtual void        StartOfCycle(AliQA::TASKINDEX_t task, Int_t run, const Bool_t sameCycle = kFALSE) ;
+       virtual void        StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle = kFALSE) ;
 
 protected: 
        
index 6aca218..8d7ea4a 100644 (file)
 // class for running the QA makers                                           //
 //                                                                           //
 //   AliQAManager qas;                                                //
-//   qas.Run(AliQA::kRAWS, rawROOTFileName);                                 //
-//   qas.Run(AliQA::kHITS);                                                  //
-//   qas.Run(AliQA::kSDIGITS);                                               //
-//   qas.Run(AliQA::kDIGITS);                                                //
-//   qas.Run(AliQA::kRECPOINTS);                                             //
-//   qas.Run(AliQA::kESDS);                                                  //
+//   qas.Run(AliQAv1::kRAWS, rawROOTFileName);                                 //
+//   qas.Run(AliQAv1::kHITS);                                                  //
+//   qas.Run(AliQAv1::kSDIGITS);                                               //
+//   qas.Run(AliQAv1::kDIGITS);                                                //
+//   qas.Run(AliQAv1::kRECPOINTS);                                             //
+//   qas.Run(AliQAv1::kESDS);                                                  //
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -52,7 +52,7 @@
 #include "AliHeader.h"
 #include "AliLog.h"
 #include "AliModule.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQADataMakerRec.h"
 #include "AliQADataMakerSim.h"
 #include "AliQAManager.h" 
@@ -91,7 +91,7 @@ AliQAManager::AliQAManager() :
        // default ctor
        fMaxEvents = fNumberOfEvents ; 
        for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
-               if (IsSelected(AliQA::GetDetName(iDet))) {
+               if (IsSelected(AliQAv1::GetDetName(iDet))) {
                        fLoader[iDet]      = NULL ;
                        fQADataMaker[iDet] = NULL ;
                        fQACycles[iDet]    = 999999 ;
@@ -125,7 +125,7 @@ AliQAManager::AliQAManager(const Char_t * mode, const Char_t* gAliceFilename) :
        // default ctor
        fMaxEvents = fNumberOfEvents ; 
        for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
-               if (IsSelected(AliQA::GetDetName(iDet))) {
+               if (IsSelected(AliQAv1::GetDetName(iDet))) {
                        fLoader[iDet]      = NULL ;
                        fQADataMaker[iDet] = NULL ;
                        fQACycles[iDet]    = 999999 ;
@@ -179,7 +179,7 @@ AliQAManager::~AliQAManager()
 {
        // dtor
        for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
-               if (IsSelected(AliQA::GetDetName(iDet))) {
+               if (IsSelected(AliQAv1::GetDetName(iDet))) {
                  fLoader[iDet] = NULL;
                  if (fQADataMaker[iDet]) {
                          (fQADataMaker[iDet])->Finish() ; 
@@ -195,7 +195,7 @@ AliQAManager::~AliQAManager()
 }
 
 //_____________________________________________________________________________
-Bool_t AliQAManager::DoIt(const AliQA::TASKINDEX_t taskIndex)
+Bool_t AliQAManager::DoIt(const AliQAv1::TASKINDEX_t taskIndex)
 {
        // Runs all the QA data Maker for every detector
                
@@ -206,10 +206,10 @@ Bool_t AliQAManager::DoIt(const AliQA::TASKINDEX_t taskIndex)
                // Get the event
                if ( iEvent%10 == 0  ) 
                        AliInfo(Form("processing event %d", iEvent));
-               if ( taskIndex == AliQA::kRAWS ) {
+               if ( taskIndex == AliQAv1::kRAWS ) {
                        if ( !fRawReader->NextEvent() )
                                break ;
-               } else if ( taskIndex == AliQA::kESDS ) {
+               } else if ( taskIndex == AliQAv1::kESDS ) {
                        if ( fESDTree->GetEntry(iEvent) == 0 )
                                break ;
                } else {
@@ -218,7 +218,7 @@ Bool_t AliQAManager::DoIt(const AliQA::TASKINDEX_t taskIndex)
                }
                // loop  over active loaders
                for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
-                       if (IsSelected(AliQA::GetDetName(iDet))) {
+                       if (IsSelected(AliQAv1::GetDetName(iDet))) {
                                AliQADataMaker * qadm = GetQADataMaker(iDet) ;
                                if (!qadm) continue; // This detector doesn't have any QA (for example, HLT)
                                if ( qadm->IsCycleDone() ) {
@@ -227,63 +227,63 @@ Bool_t AliQAManager::DoIt(const AliQA::TASKINDEX_t taskIndex)
                                TTree * data = NULL ; 
                                AliLoader* loader = GetLoader(qadm->GetUniqueID());
                                switch (taskIndex) {
-                                       case AliQA::kNULLTASKINDEX : 
+                                       case AliQAv1::kNULLTASKINDEX : 
                                                break ; 
-                                       case AliQA::kRAWS :
+                                       case AliQAv1::kRAWS :
                                                qadm->Exec(taskIndex, fRawReader) ; 
                                                break ; 
-                                       case AliQA::kHITS :
+                                       case AliQAv1::kHITS :
             if( loader ) {
               loader->LoadHits() ; 
               data = loader->TreeH() ; 
               if ( ! data ) {
-                AliWarning(Form(" Hit Tree not found for  %s", AliQA::GetDetName(iDet))) ; 
+                AliWarning(Form(" Hit Tree not found for  %s", AliQAv1::GetDetName(iDet))) ; 
                 break ; 
               } 
             } 
             qadm->Exec(taskIndex, data) ;
                                                break ;
-                                               case AliQA::kSDIGITS :
+                                               case AliQAv1::kSDIGITS :
             if( loader ) {      
               loader->LoadSDigits() ; 
               data = loader->TreeS() ; 
               if ( ! data ) {
-                AliWarning(Form(" SDigit Tree not found for  %s", AliQA::GetDetName(iDet))) ; 
+                AliWarning(Form(" SDigit Tree not found for  %s", AliQAv1::GetDetName(iDet))) ; 
                 break ; 
               } 
             }
             qadm->Exec(taskIndex, data) ; 
                                                break; 
-                                               case AliQA::kDIGITS :
+                                               case AliQAv1::kDIGITS :
             if( loader ) {      
               loader->LoadDigits() ; 
               data = loader->TreeD() ; 
               if ( ! data ) {
-                AliWarning(Form(" Digit Tree not found for  %s", AliQA::GetDetName(iDet))) ; 
+                AliWarning(Form(" Digit Tree not found for  %s", AliQAv1::GetDetName(iDet))) ; 
                 break ; 
               } 
             }
             qadm->Exec(taskIndex, data) ;
                                                break; 
-                                               case AliQA::kRECPOINTS :
+                                               case AliQAv1::kRECPOINTS :
             if( loader ) {      
               loader->LoadRecPoints() ; 
               data = loader->TreeR() ; 
               if (!data) {
-                AliWarning(Form("RecPoints not found for %s", AliQA::GetDetName(iDet))) ; 
+                AliWarning(Form("RecPoints not found for %s", AliQAv1::GetDetName(iDet))) ; 
                 break ; 
               } 
             }
             qadm->Exec(taskIndex, data) ; 
             break; 
-                                               case AliQA::kTRACKSEGMENTS :
+                                               case AliQAv1::kTRACKSEGMENTS :
                                                break; 
-                                               case AliQA::kRECPARTICLES :
+                                               case AliQAv1::kRECPARTICLES :
                                                break; 
-                                               case AliQA::kESDS :
+                                               case AliQAv1::kESDS :
                                                qadm->Exec(taskIndex, fESD) ;
                                                break; 
-                                               case AliQA::kNTASKINDEX :
+                                               case AliQAv1::kNTASKINDEX :
                                                break; 
                                } //task switch
                        }
@@ -293,18 +293,18 @@ Bool_t AliQAManager::DoIt(const AliQA::TASKINDEX_t taskIndex)
        // Save QA data for all detectors
        rv = Finish(taskIndex) ;
        
-       if ( taskIndex == AliQA::kRAWS ) 
+       if ( taskIndex == AliQAv1::kRAWS ) 
                fRawReader->RewindEvents() ;
 
        return rv ; 
 }
 
 //_____________________________________________________________________________
-Bool_t AliQAManager::Finish(const AliQA::TASKINDEX_t taskIndex) 
+Bool_t AliQAManager::Finish(const AliQAv1::TASKINDEX_t taskIndex) 
 {
        // write output to file for all detectors
        for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
-               if (IsSelected(AliQA::GetDetName(iDet))) {
+               if (IsSelected(AliQAv1::GetDetName(iDet))) {
                        AliQADataMaker * qadm = GetQADataMaker(iDet) ;
                        if (qadm) 
         qadm->EndOfCycle(taskIndex) ;
@@ -314,27 +314,27 @@ Bool_t AliQAManager::Finish(const AliQA::TASKINDEX_t taskIndex)
 }
 
 //_____________________________________________________________________________
-TObjArray * AliQAManager::GetFromOCDB(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, const char * year) const 
+TObjArray * AliQAManager::GetFromOCDB(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, const char * year) const 
 {
        // Retrieve the list of QA data for a given detector and a given task 
        TObjArray * rv = NULL ;
-       if ( !strlen(AliQA::GetQARefStorage()) ) { 
-               AliError("No storage defined, use AliQA::SetQARefStorage") ; 
+       if ( !strlen(AliQAv1::GetQARefStorage()) ) { 
+               AliError("No storage defined, use AliQAv1::SetQARefStorage") ; 
                return NULL ; 
        }       
        if ( ! IsDefaultStorageSet() ) {
-               TString tmp(AliQA::GetQARefDefaultStorage()) ; 
+               TString tmp(AliQAv1::GetQARefDefaultStorage()) ; 
                tmp.Append(year) ; 
                tmp.Append("/") ; 
                Instance()->SetDefaultStorage(tmp.Data()) ;             
-               Instance()->SetSpecificStorage(Form("%s/*", AliQA::GetQAName()), AliQA::GetQARefStorage()) ;
+               Instance()->SetSpecificStorage(Form("%s/*", AliQAv1::GetQAName()), AliQAv1::GetQARefStorage()) ;
        }
-       TString detOCDBDir(Form("%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.Data(), AliQA::GetTaskName(task).Data())) ; 
+       TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetQAName(), AliQAv1::GetDetName((Int_t)det), AliQAv1::GetRefOCDBDirName())) ; 
+       AliInfo(Form("Retrieving reference data from %s/%s for %s", AliQAv1::GetQARefStorage(), detOCDBDir.Data(), AliQAv1::GetTaskName(task).Data())) ; 
        AliCDBEntry* entry = QAManager()->Get(detOCDBDir.Data(), 0) ; //FIXME 0 --> Run Number
        TList * listDetQAD = dynamic_cast<TList *>(entry->GetObject()) ;
        if ( listDetQAD ) 
-               rv = dynamic_cast<TObjArray *>(listDetQAD->FindObject(AliQA::GetTaskName(task))) ; 
+               rv = dynamic_cast<TObjArray *>(listDetQAD->FindObject(AliQAv1::GetTaskName(task))) ; 
        return rv ; 
 }
 
@@ -343,10 +343,10 @@ AliLoader * AliQAManager::GetLoader(Int_t iDet)
 {
        // get the loader for a detector
 
-       if ( !fRunLoader || iDet == AliQA::kCORR) 
+       if ( !fRunLoader || iDet == AliQAv1::kCORR) 
                return NULL ; 
        
-       TString detName = AliQA::GetDetName(iDet) ;
+       TString detName = AliQAv1::GetDetName(iDet) ;
     fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
        if (fLoader[iDet]) 
                return fLoader[iDet] ;
@@ -378,7 +378,7 @@ AliLoader * AliQAManager::GetLoader(Int_t iDet)
 }
 
 //_____________________________________________________________________________
-AliQA * AliQAManager::GetQA(UInt_t run, UInt_t evt) 
+AliQAv1 * AliQAManager::GetQA(UInt_t run, UInt_t evt) 
 {
 // retrieves the QA object stored in a file named "Run{run}.Event{evt}_1.ESD.tag.root"  
   char * fileName = Form("Run%d.Event%d_1.ESD.tag.root", run, evt) ; 
@@ -396,7 +396,7 @@ AliQA * AliQAManager::GetQA(UInt_t run, UInt_t evt)
   AliRunTag * tag = new AliRunTag ; 
   tagTree->SetBranchAddress("AliTAG", &tag) ; 
   tagTree->GetEntry(evt) ; 
-  AliQA * qa = AliQA::Instance(tag->GetQALength(), tag->GetQAArray(), tag->GetESLength(), tag->GetEventSpecies()) ; 
+  AliQAv1 * qa = AliQAv1::Instance(tag->GetQALength(), tag->GetQAArray(), tag->GetESLength(), tag->GetEventSpecies()) ; 
   tagFile->Close() ; 
   return qa ; 
 }
@@ -413,18 +413,18 @@ AliQADataMaker * AliQAManager::GetQADataMaker(const Int_t iDet)
        
        AliQADataMaker * qadm = NULL ;
        
-       if (iDet == AliQA::kGLOBAL) { //Global QA
+       if (iDet == AliQAv1::kGLOBAL) { //Global QA
                qadm = new AliGlobalQADataMaker();
-               qadm->SetName(AliQA::GetDetName(iDet));
+               qadm->SetName(AliQAv1::GetDetName(iDet));
                qadm->SetUniqueID(iDet);
                fQADataMaker[iDet] = qadm;
     qadm->SetEventSpecie(fEventSpecie) ; 
                return qadm;
        }
 
-       if (iDet == AliQA::kCORR) { //the data maker for correlations among detectors
+       if (iDet == AliQAv1::kCORR) { //the data maker for correlations among detectors
     qadm = new AliCorrQADataMakerRec(fQADataMaker) ; 
-               qadm->SetName(AliQA::GetDetName(iDet));
+               qadm->SetName(AliQAv1::GetDetName(iDet));
                qadm->SetUniqueID(iDet);
                fQADataMaker[iDet] = qadm;
     qadm->SetEventSpecie(fEventSpecie) ; 
@@ -433,7 +433,7 @@ AliQADataMaker * AliQAManager::GetQADataMaker(const Int_t iDet)
 
        // load the QA data maker object
        TPluginManager* pluginManager = gROOT->GetPluginManager() ;
-       TString detName = AliQA::GetDetName(iDet) ;
+       TString detName = AliQAv1::GetDetName(iDet) ;
        TString tmp(fMode) ; 
        if (tmp.Contains("sim")) 
                tmp.ReplaceAll("s", "S") ; 
@@ -459,7 +459,7 @@ AliQADataMaker * AliQAManager::GetQADataMaker(const Int_t iDet)
                qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0) ;
        }
        if (qadm) {
-               qadm->SetName(AliQA::GetDetName(iDet));
+               qadm->SetName(AliQAv1::GetDetName(iDet));
                qadm->SetUniqueID(iDet);
                fQADataMaker[iDet] = qadm ;
     qadm->SetEventSpecie(fEventSpecie) ; 
@@ -474,19 +474,19 @@ void  AliQAManager::EndOfCycle(TObjArray * detArray)
        // End of cycle QADataMakers 
        
        for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
-               if (IsSelected(AliQA::GetDetName(iDet))) {
+               if (IsSelected(AliQAv1::GetDetName(iDet))) {
                        AliQADataMaker * qadm = GetQADataMaker(iDet) ;
                        if (!qadm) 
                                continue ;      
                        // skip non active detectors
                        if (detArray) {
-                               AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQA::GetDetName(iDet))) ;
+                               AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQAv1::GetDetName(iDet))) ;
                                if (!det || !det->IsActive())  
                                        continue ;
                        }
-                       for (UInt_t taskIndex = 0; taskIndex < AliQA::kNTASKINDEX; taskIndex++) {
+                       for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
                                if ( fTasks.Contains(Form("%d", taskIndex)) ) 
-                                       qadm->EndOfCycle(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex))) ;
+                                       qadm->EndOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex))) ;
                        }
                        qadm->Finish();
                }
@@ -499,16 +499,16 @@ void  AliQAManager::EndOfCycle(TString detectors)
        // End of cycle QADataMakers 
        
        for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
-               if (IsSelected(AliQA::GetDetName(iDet))) {
+               if (IsSelected(AliQAv1::GetDetName(iDet))) {
                        AliQADataMaker * qadm = GetQADataMaker(iDet) ;
                        if (!qadm) 
                                continue ;      
                        // skip non active detectors
-      if (!detectors.Contains(AliQA::GetDetName(iDet))) 
+      if (!detectors.Contains(AliQAv1::GetDetName(iDet))) 
         continue ;
-               for (UInt_t taskIndex = 0; taskIndex < AliQA::kNTASKINDEX; taskIndex++) {
+               for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
                                if ( fTasks.Contains(Form("%d", taskIndex)) ) 
-                                       qadm->EndOfCycle(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex))) ;
+                                       qadm->EndOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex))) ;
                        }
                        qadm->Finish();
                }
@@ -520,7 +520,7 @@ void AliQAManager::Increment()
 {
   // Increments the cycle counter for all QA Data Makers
        for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
-               if (IsSelected(AliQA::GetDetName(iDet))) {
+               if (IsSelected(AliQAv1::GetDetName(iDet))) {
                        AliQADataMaker * qadm = GetQADataMaker(iDet) ;
                        if (qadm) 
         qadm->Increment() ;
@@ -529,13 +529,13 @@ void AliQAManager::Increment()
 }
   
 //_____________________________________________________________________________
-Bool_t AliQAManager::InitQA(const AliQA::TASKINDEX_t taskIndex, const  char * input )
+Bool_t AliQAManager::InitQA(const AliQAv1::TASKINDEX_t taskIndex, const  char * input )
 {
        // Initialize the event source and QA data makers
        
        fTasks += Form("%d", taskIndex) ; 
 
-       if (taskIndex == AliQA::kRAWS) { 
+       if (taskIndex == AliQAv1::kRAWS) { 
                if (!fRawReader) {
                        fRawReader = AliRawReader::Create(input);
                }
@@ -549,8 +549,8 @@ Bool_t AliQAManager::InitQA(const AliQA::TASKINDEX_t taskIndex, const  char * in
                fNumberOfEvents = 999999 ;
                if ( fMaxEvents < 0 ) 
                        fMaxEvents = fNumberOfEvents ; 
-               } else if (taskIndex == AliQA::kESDS) {
-                       fTasks = AliQA::GetTaskName(AliQA::kESDS) ; 
+               } else if (taskIndex == AliQAv1::kESDS) {
+                       fTasks = AliQAv1::GetTaskName(AliQAv1::kESDS) ; 
       if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
         TFile * esdFile = TFile::Open("AliESDs.root") ;
         fESDTree = dynamic_cast<TTree *> (esdFile->Get("esdTree")) ; 
@@ -602,27 +602,27 @@ void  AliQAManager::InitQADataMaker(UInt_t run, TObjArray * detArray)
 {
        // Initializes The QADataMaker for all active detectors and for all active tasks 
        for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
-               if (IsSelected(AliQA::GetDetName(iDet))) {
+               if (IsSelected(AliQAv1::GetDetName(iDet))) {
                        AliQADataMaker * qadm = GetQADataMaker(iDet) ;
                        if (!qadm) {
-                               AliError(Form("AliQADataMaker not found for %s", AliQA::GetDetName(iDet))) ; 
-                               fDetectorsW.ReplaceAll(AliQA::GetDetName(iDet), "") ; 
+                               AliError(Form("AliQADataMaker not found for %s", AliQAv1::GetDetName(iDet))) ; 
+                               fDetectorsW.ReplaceAll(AliQAv1::GetDetName(iDet), "") ; 
                        } else {
         if (fQAWriteExpert[iDet])
           qadm->SetWriteExpert() ; 
                                AliDebug(1, Form("Data Maker found for %s %d", qadm->GetName(), qadm->WriteExpert())) ; 
                                // skip non active detectors
                                if (detArray) {
-                                       AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQA::GetDetName(iDet))) ;
+                                       AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQAv1::GetDetName(iDet))) ;
                                        if (!det || !det->IsActive())  
                                                continue ;
                                }
              // Set default reco params
         Bool_t sameCycle = kFALSE ; 
-                               for (UInt_t taskIndex = 0; taskIndex < AliQA::kNTASKINDEX; taskIndex++) {
+                               for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
                                        if ( fTasks.Contains(Form("%d", taskIndex)) ) {
-                                               qadm->Init(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex)), GetQACycles(qadm->GetUniqueID())) ;
-            qadm->StartOfCycle(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex)), run,  sameCycle) ;
+                                               qadm->Init(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), GetQACycles(qadm->GetUniqueID())) ;
+            qadm->StartOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), run,  sameCycle) ;
             sameCycle = kTRUE ;
                                        }
                                }
@@ -643,9 +643,9 @@ Bool_t AliQAManager::InitRunLoader()
                        // load all base libraries to get the loader classes
                        TString libs = gSystem->GetLibraries() ;
                        for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
-                               if (!IsSelected(AliQA::GetDetName(iDet))) 
+                               if (!IsSelected(AliQAv1::GetDetName(iDet))) 
                                        continue ; 
-                               TString detName = AliQA::GetDetName(iDet) ;
+                               TString detName = AliQAv1::GetDetName(iDet) ;
                                if (detName == "HLT") 
                                        continue;
                                if (libs.Contains("lib" + detName + "base.so")) 
@@ -689,7 +689,7 @@ Bool_t AliQAManager::IsSelected(const char * det)
        Bool_t rv = kFALSE;
        const TString detName(det) ;
   // always activates Correlation
-  if ( detName.Contains(AliQA::GetDetName(AliQA::kCORR))) {
+  if ( detName.Contains(AliQAv1::GetDetName(AliQAv1::kCORR))) {
     rv = kTRUE ; 
   } else {
     // check if all detectors are selected
@@ -814,19 +814,19 @@ void AliQAManager::MergeCustom() const
   }
   nextRun.Reset() ;    
   Int_t runNumber = 0 ; 
-  TFile mergedFile(Form("Merged.%s.Data.root", AliQA::GetQADataFileName()), "RECREATE") ; 
+  TFile mergedFile(Form("Merged.%s.Data.root", AliQAv1::GetQADataFileName()), "RECREATE") ; 
   TH1I * hisRun = new TH1I("hLMR", "List of merged runs", hiRun-loRun+10, loRun, hiRun+10) ; 
   // create the structure into the merged file
-  for (Int_t iDet = 0; iDet < AliQA::kNDET ; iDet++) {
-    TDirectory * detDir = mergedFile.mkdir(AliQA::GetDetName(iDet)) ; 
-    for (Int_t taskIndex = 0; taskIndex < AliQA::kNTASKINDEX; taskIndex++) {
+  for (Int_t iDet = 0; iDet < AliQAv1::kNDET ; iDet++) {
+    TDirectory * detDir = mergedFile.mkdir(AliQAv1::GetDetName(iDet)) ; 
+    for (Int_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
       detDir->cd() ; 
-      TDirectory * taskDir = gDirectory->mkdir(AliQA::GetTaskName(taskIndex)) ; 
+      TDirectory * taskDir = gDirectory->mkdir(AliQAv1::GetTaskName(taskIndex)) ; 
       for (Int_t es = 0 ; es < AliRecoParam::kNSpecies ; es++) {
         taskDir->cd() ; 
         TDirectory * esDir = gDirectory->mkdir(AliRecoParam::GetEventSpecieName(es)) ;
         esDir->cd() ; 
-        gDirectory->mkdir(AliQA::GetExpert()) ; 
+        gDirectory->mkdir(AliQAv1::GetExpert()) ; 
       }
     }
   }
@@ -835,10 +835,10 @@ void AliQAManager::MergeCustom() const
     hisRun->Fill(runNumber) ; 
     AliInfo(Form("Merging run number %d", runNumber)) ; 
     // search all QA files for runNumber in the current directory
-    char * fileList[AliQA::kNDET] ;
+    char * fileList[AliQAv1::kNDET] ;
     index = 0 ; 
-    for (Int_t iDet = 0; iDet < AliQA::kNDET ; iDet++) {
-      char * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQA::GetDetName(iDet), AliQA::GetQADataFileName(), runNumber)); 
+    for (Int_t iDet = 0; iDet < AliQAv1::kNDET ; iDet++) {
+      char * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQAv1::GetDetName(iDet), AliQAv1::GetQADataFileName(), runNumber)); 
       if (file) 
         fileList[index++] = file ;
     }
@@ -943,10 +943,10 @@ Bool_t AliQAManager::MergeData(const Int_t runNumber) const
        // Merge QA data from all detectors for a given run in one single file 
   
   TFileMerger merger ; 
-  TString outFileName = Form("Merged.%s.Data.root",AliQA::GetQADataFileName()) ;
+  TString outFileName = Form("Merged.%s.Data.root",AliQAv1::GetQADataFileName()) ;
   merger.OutputFile(outFileName.Data()) ; 
   for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
-    char * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQA::GetDetName(iDet), AliQA::GetQADataFileName(), runNumber)); 
+    char * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQAv1::GetDetName(iDet), AliQAv1::GetQADataFileName(), runNumber)); 
     if (file) 
       merger.AddFile(file) ; 
   }
@@ -960,7 +960,7 @@ Bool_t AliQAManager::MergeResults(const Int_t runNumber) const
        // Merge the QA result from all the data chunks in a run 
   // to be revised whwn it will be used (see MergeData)
        TString cmd ;
-       cmd = Form(".! ls %s*.root > tempo.txt", AliQA::GetQADataFileName()) ; 
+       cmd = Form(".! ls %s*.root > tempo.txt", AliQAv1::GetQADataFileName()) ; 
        gROOT->ProcessLine(cmd.Data()) ;
        ifstream in("tempo.txt") ; 
        const Int_t chunkMax = 100 ;  
@@ -984,9 +984,9 @@ Bool_t AliQAManager::MergeResults(const Int_t runNumber) const
        TFileMerger merger ; 
   TString outFileName ;
   if (runNumber != -1) 
-    outFileName = Form("Merged.%s.Result.%d.root",AliQA::GetQADataFileName(),runNumber); 
+    outFileName = Form("Merged.%s.Result.%d.root",AliQAv1::GetQADataFileName(),runNumber); 
   else 
-    outFileName = Form("Merged.%s.Result.root",AliQA::GetQADataFileName()); 
+    outFileName = Form("Merged.%s.Result.root",AliQAv1::GetQADataFileName()); 
        merger.OutputFile(outFileName.Data()) ; 
        for (Int_t ifile = 0 ; ifile < index ; ifile++) {
                TString file = fileList[ifile] ; 
@@ -1003,7 +1003,7 @@ void AliQAManager::Reset(const Bool_t sameCycle)
        // Reset the default data members
 
        for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
-               if (IsSelected(AliQA::GetDetName(iDet))) {
+               if (IsSelected(AliQAv1::GetDetName(iDet))) {
                        AliQADataMaker * qadm = GetQADataMaker(iDet);
                        qadm->Reset();
                }
@@ -1054,11 +1054,11 @@ TString AliQAManager::Run(const char * detectors, AliRawReader * rawReader, cons
        }       
        
        if (!fCycleSame) 
-    if ( !InitQA(AliQA::kRAWS) ) 
+    if ( !InitQA(AliQAv1::kRAWS) ) 
       return kFALSE ; 
   fRawReaderDelete = kFALSE ; 
 
-       DoIt(AliQA::kRAWS) ; 
+       DoIt(AliQAv1::kRAWS) ; 
        return  fDetectorsW ;
 }
 
@@ -1089,15 +1089,15 @@ TString AliQAManager::Run(const char * detectors, const char * fileName, const B
        }
        
        if (!fCycleSame) 
-    if ( !InitQA(AliQA::kRAWS, fileName) ) 
+    if ( !InitQA(AliQAv1::kRAWS, fileName) ) 
       return kFALSE ; 
        
-       DoIt(AliQA::kRAWS) ; 
+       DoIt(AliQAv1::kRAWS) ; 
        return  fDetectorsW ;
 }
 
 //_____________________________________________________________________________
-TString AliQAManager::Run(const char * detectors, const AliQA::TASKINDEX_t taskIndex, Bool_t const sameCycle, const  char * fileName ) 
+TString AliQAManager::Run(const char * detectors, const AliQAv1::TASKINDEX_t taskIndex, Bool_t const sameCycle, const  char * fileName ) 
 {
        // Runs all the QA data Maker for every detector
        
@@ -1123,13 +1123,13 @@ TString AliQAManager::Run(const char * detectors, const AliQA::TASKINDEX_t taskI
        }
        
 
-       if ( taskIndex == AliQA::kNULLTASKINDEX) { 
-               for (UInt_t task = 0; task < AliQA::kNTASKINDEX; task++) {
+       if ( taskIndex == AliQAv1::kNULLTASKINDEX) { 
+               for (UInt_t task = 0; task < AliQAv1::kNTASKINDEX; task++) {
                        if ( fTasks.Contains(Form("%d", task)) ) {
         if (!fCycleSame)
-          if ( !InitQA(AliQA::GetTaskIndex(AliQA::GetTaskName(task)), fileName) ) 
+          if ( !InitQA(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(task)), fileName) ) 
             return kFALSE ;
-        DoIt(AliQA::GetTaskIndex(AliQA::GetTaskName(task))) ;
+        DoIt(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(task))) ;
                        }
                }
        } else {
@@ -1150,9 +1150,9 @@ void AliQAManager::RunOneEvent(AliRawReader * rawReader)
   if ( ! rawReader ) 
     return ; 
        AliCodeTimerAuto("") ;
-  if (fTasks.Contains(Form("%d", AliQA::kRAWS))){
+  if (fTasks.Contains(Form("%d", AliQAv1::kRAWS))){
     for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
-      if (!IsSelected(AliQA::GetDetName(iDet))) 
+      if (!IsSelected(AliQAv1::GetDetName(iDet))) 
         continue;
       AliQADataMaker *qadm = GetQADataMaker(iDet);  
       if (!qadm) 
@@ -1160,10 +1160,10 @@ void AliQAManager::RunOneEvent(AliRawReader * rawReader)
       if ( qadm->IsCycleDone() ) {
         qadm->EndOfCycle() ;
       }
-      AliCodeTimerStart(Form("running RAW quality assurance data maker for %s", AliQA::GetDetName(iDet))); 
+      AliCodeTimerStart(Form("running RAW quality assurance data maker for %s", AliQAv1::GetDetName(iDet))); 
       qadm->SetEventSpecie(fEventSpecie) ; 
-                       qadm->Exec(AliQA::kRAWS, rawReader) ;
-      AliCodeTimerStop(Form("running RAW quality assurance data maker for %s", AliQA::GetDetName(iDet)));
+                       qadm->Exec(AliQAv1::kRAWS, rawReader) ;
+      AliCodeTimerStop(Form("running RAW quality assurance data maker for %s", AliQAv1::GetDetName(iDet)));
                }
   }
 }
@@ -1174,9 +1174,9 @@ void AliQAManager::RunOneEvent(AliESDEvent *& esd)
        //Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
        
   AliCodeTimerAuto("") ;
-  if (fTasks.Contains(Form("%d", AliQA::kESDS))) {
+  if (fTasks.Contains(Form("%d", AliQAv1::kESDS))) {
     for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
-      if (!IsSelected(AliQA::GetDetName(iDet))) 
+      if (!IsSelected(AliQAv1::GetDetName(iDet))) 
         continue;
       AliQADataMaker *qadm = GetQADataMaker(iDet);  
       if (!qadm) 
@@ -1184,9 +1184,9 @@ void AliQAManager::RunOneEvent(AliESDEvent *& esd)
       if ( qadm->IsCycleDone() ) {
         qadm->EndOfCycle() ;
       }
-      AliCodeTimerStart(Form("running ESD quality assurance data maker for %s", AliQA::GetDetName(iDet)));
-                       qadm->Exec(AliQA::kESDS, esd) ;
-      AliCodeTimerStop(Form("running ESD quality assurance data maker for %s", AliQA::GetDetName(iDet)));
+      AliCodeTimerStart(Form("running ESD quality assurance data maker for %s", AliQAv1::GetDetName(iDet)));
+                       qadm->Exec(AliQAv1::kESDS, esd) ;
+      AliCodeTimerStop(Form("running ESD quality assurance data maker for %s", AliQAv1::GetDetName(iDet)));
                }
        }
 }
@@ -1196,16 +1196,16 @@ void AliQAManager::RunOneEventInOneDetector(Int_t det, TTree * tree)
 {
        // Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
        AliCodeTimerAuto("") ;
-  if (fTasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
-    if (IsSelected(AliQA::GetDetName(det))) {
+  if (fTasks.Contains(Form("%d", AliQAv1::kRECPOINTS))) {
+    if (IsSelected(AliQAv1::GetDetName(det))) {
       AliQADataMaker *qadm = GetQADataMaker(det);  
       if (qadm) { 
         if ( qadm->IsCycleDone() ) {
           qadm->EndOfCycle() ;
         }
-        AliCodeTimerStart(Form("running RecPoints quality assurance data maker for %s", AliQA::GetDetName(det)));
-        qadm->Exec(AliQA::kRECPOINTS, tree) ;
-        AliCodeTimerStop(Form("running RecPoints quality assurance data maker for %s", AliQA::GetDetName(det)));
+        AliCodeTimerStart(Form("running RecPoints quality assurance data maker for %s", AliQAv1::GetDetName(det)));
+        qadm->Exec(AliQAv1::kRECPOINTS, tree) ;
+        AliCodeTimerStop(Form("running RecPoints quality assurance data maker for %s", AliQAv1::GetDetName(det)));
       }
     }
   }
@@ -1216,13 +1216,13 @@ Bool_t AliQAManager::Save2OCDB(const Int_t runNumber, AliRecoParam::EventSpecie_
 {
        // take the locasl QA data merge into a single file and save in OCDB 
        Bool_t rv = kTRUE ; 
-       TString tmp(AliQA::GetQARefStorage()) ; 
+       TString tmp(AliQAv1::GetQARefStorage()) ; 
        if ( tmp.IsNull() ) { 
-               AliError("No storage defined, use AliQA::SetQARefStorage") ; 
+               AliError("No storage defined, use AliQAv1::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())) ; 
+       if ( !(tmp.Contains(AliQAv1::GetLabLocalOCDB()) || tmp.Contains(AliQAv1::GetLabAliEnOCDB())) ) {
+               AliError(Form("%s is a wrong storage, use %s or %s", AliQAv1::GetQARefStorage(), AliQAv1::GetLabLocalOCDB().Data(), AliQAv1::GetLabAliEnOCDB().Data())) ; 
                return kFALSE ; 
        }
        TString sdet(detectors) ; 
@@ -1232,13 +1232,13 @@ Bool_t AliQAManager::Save2OCDB(const Int_t runNumber, AliRecoParam::EventSpecie_
                rv = Merge(runNumber) ; 
                if ( ! rv )
                        return kFALSE ; 
-               TString inputFileName(Form("Merged.%s.Data.%d.root", AliQA::GetQADataFileName(), runNumber)) ; 
+               TString inputFileName(Form("Merged.%s.Data.%d.root", AliQAv1::GetQADataFileName(), runNumber)) ; 
                inputFile = TFile::Open(inputFileName.Data()) ; 
                rv = SaveIt2OCDB(runNumber, inputFile, year, es) ; 
        } else {
-               for (Int_t index = 0; index < AliQA::kNDET; index++) {
-                       if (sdet.Contains(AliQA::GetDetName(index))) {
-                               TString inputFileName(Form("%s.%s.%d.root", AliQA::GetDetName(index), AliQA::GetQADataFileName(), runNumber)) ; 
+               for (Int_t index = 0; index < AliQAv1::kNDET; index++) {
+                       if (sdet.Contains(AliQAv1::GetDetName(index))) {
+                               TString inputFileName(Form("%s.%s.%d.root", AliQAv1::GetDetName(index), AliQAv1::GetQADataFileName(), runNumber)) ; 
                                inputFile = TFile::Open(inputFileName.Data()) ;                         
                                rv *= SaveIt2OCDB(runNumber, inputFile, year, es) ; 
                        }
@@ -1252,35 +1252,35 @@ Bool_t AliQAManager::SaveIt2OCDB(const Int_t runNumber, 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())) ; 
+       AliInfo(Form("Saving TH1s in %s to %s", inputFile->GetName(), AliQAv1::GetQARefStorage())) ; 
        if ( ! IsDefaultStorageSet() ) {
-               TString tmp( AliQA::GetQARefStorage() ) ; 
-               if ( tmp.Contains(AliQA::GetLabLocalOCDB()) ) 
-                       Instance()->SetDefaultStorage(AliQA::GetQARefStorage()) ;
+               TString tmp( AliQAv1::GetQARefStorage() ) ; 
+               if ( tmp.Contains(AliQAv1::GetLabLocalOCDB()) ) 
+                       Instance()->SetDefaultStorage(AliQAv1::GetQARefStorage()) ;
                else {
-                       TString tmp1(AliQA::GetQARefDefaultStorage()) ; 
+                       TString tmp1(AliQAv1::GetQARefDefaultStorage()) ; 
                        tmp1.Append(year) ; 
                        tmp1.Append("?user=alidaq") ; 
                        Instance()->SetDefaultStorage(tmp1.Data()) ; 
                }
        }
-       Instance()->SetSpecificStorage("*", AliQA::GetQARefStorage()) ; 
+       Instance()->SetSpecificStorage("*", AliQAv1::GetQARefStorage()) ; 
        if(GetRun() < 0) 
                Instance()->SetRun(runNumber);
 
        AliCDBMetaData mdr ;
        mdr.SetResponsible("yves schutz");
 
-       for ( Int_t detIndex = 0 ; detIndex < AliQA::kNDET ; detIndex++) {
-               TDirectory * detDir = inputFile->GetDirectory(AliQA::GetDetName(detIndex)) ; 
+       for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++) {
+               TDirectory * detDir = inputFile->GetDirectory(AliQAv1::GetDetName(detIndex)) ; 
                if ( detDir ) {
                        AliInfo(Form("Entering %s", detDir->GetName())) ;
-      AliQA::SetQARefDataDirName(es) ;
-                       TString detOCDBDir(Form("%s/%s/%s", AliQA::GetDetName(detIndex), AliQA::GetRefOCDBDirName(), AliQA::GetRefDataDirName())) ; 
+      AliQAv1::SetQARefDataDirName(es) ;
+                       TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetDetName(detIndex), AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName())) ; 
                        AliCDBId idr(detOCDBDir.Data(), runNumber, AliCDBRunRange::Infinity())  ;
                        TList * listDetQAD = new TList() ;
-                       TString listName(Form("%s QA data Reference", AliQA::GetDetName(detIndex))) ; 
-                       mdr.SetComment(Form("%s QA stuff", AliQA::GetDetName(detIndex)));
+                       TString listName(Form("%s QA data Reference", AliQAv1::GetDetName(detIndex))) ; 
+                       mdr.SetComment(Form("%s QA stuff", AliQAv1::GetDetName(detIndex)));
                        listDetQAD->SetName(listName) ; 
                        TList * taskList = detDir->GetListOfKeys() ; 
                        TIter nextTask(taskList) ; 
@@ -1300,7 +1300,7 @@ Bool_t AliQAManager::SaveIt2OCDB(const Int_t runNumber, TFile * inputFile, const
                                        if ( !odata ) {
                                                AliError(Form("%s in %s/%s returns a NULL pointer !!", histKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
                                        } else {
-            if ( AliQA::GetExpert() == histKey->GetName() ) {
+            if ( AliQAv1::GetExpert() == histKey->GetName() ) {
               TDirectory * expertDir   = esDir->GetDirectory(histKey->GetName()) ; 
               TList * expertHistList = expertDir->GetListOfKeys() ; 
               TIter nextExpertHist(expertHistList) ; 
@@ -1337,9 +1337,9 @@ Bool_t AliQAManager::SaveIt2OCDB(const Int_t runNumber, TFile * inputFile, const
 //_____________________________________________________________________________
 void AliQAManager::SetEventSpecie(AliRecoParam::EventSpecie_t es) 
 {
-  // set the current event specie and inform AliQA that this event specie has been encountered
+  // set the current event specie and inform AliQAv1 that this event specie has been encountered
   fEventSpecie = es ;
-  AliQA::Instance()->SetEventSpecie(es) ; 
+  AliQAv1::Instance()->SetEventSpecie(es) ; 
 }
 
 //_____________________________________________________________________________
@@ -1355,7 +1355,7 @@ void AliQAManager::SetWriteExpert()
 {
   // enable the writing of QA expert data
   for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
-       if (IsSelected(AliQA::GetDetName(iDet))) 
+       if (IsSelected(AliQAv1::GetDetName(iDet))) 
       fQAWriteExpert[iDet] = kTRUE ;
   }
 }  
index d7b20ad..911dbbc 100644 (file)
 // class for running the QA makers                                           //
 //                                                                           //
 //   AliQAManager qas;                                                //
-//   qas.Run(AliQA::kRAWS, rawROOTFileName);                                 //
-//   qas.Run(AliQA::kHITS);                                                  //
-//   qas.Run(AliQA::kSDIGITS);                                               //
-//   qas.Run(AliQA::kDIGITS);                                                //
-//   qas.Run(AliQA::kRECPOINTS);                                             //
-//   qas.Run(AliQA::kESDS);                                                  //
+//   qas.Run(AliQAv1::kRAWS, rawROOTFileName);                                 //
+//   qas.Run(AliQAv1::kHITS);                                                  //
+//   qas.Run(AliQAv1::kSDIGITS);                                               //
+//   qas.Run(AliQAv1::kDIGITS);                                                //
+//   qas.Run(AliQAv1::kRECPOINTS);                                             //
+//   qas.Run(AliQAv1::kESDS);                                                  //
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <TNamed.h>
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliLoader.h"
 #include "AliCDBManager.h"
 #include "AliRecoParam.h"
@@ -45,8 +45,8 @@ public:
        void        EndOfCycle(TObjArray * detArray=0x0) ; 
   void        EndOfCycle(TString detectors) ; 
        UInt_t      GetCurrentEvent() const { return fCurrentEvent ; }
-       TObjArray * GetFromOCDB(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, const char * year) const ; 
-  AliQA     * GetQA(UInt_t run, UInt_t evt) ; 
+       TObjArray * GetFromOCDB(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, const char * year) const ; 
+  AliQAv1     * GetQA(UInt_t run, UInt_t evt) ; 
        AliQADataMaker * GetQADataMaker(const Int_t iDet) ; 
        void        Increment() ;
        void        InitQADataMaker(UInt_t run, TObjArray * detArray=0x0) ;
@@ -55,7 +55,7 @@ public:
   Bool_t      MergeXML(const char * collection, const char * subFile = 0, const char * outFile = 0) ; 
   static      AliQAManager * QAManager(const Char_t * mode="", TMap *entryCache = NULL, Int_t run = -1) ;
        void        Reset(const Bool_t sameCycle = kFALSE) ;  
-       TString     Run(const char * detectors, const AliQA::TASKINDEX_t taskIndex=AliQA::kNULLTASKINDEX, Bool_t const sameCycle = kFALSE, const char * fileName = NULL) ; 
+       TString     Run(const char * detectors, const AliQAv1::TASKINDEX_t taskIndex=AliQAv1::kNULLTASKINDEX, Bool_t const sameCycle = kFALSE, const char * fileName = NULL) ; 
        TString     Run(const char * detectors, AliRawReader * rawReader, Bool_t const sameCycle = kFALSE) ; 
        TString     Run(const char * detectors, const char * filename, Bool_t const sameCycle = kFALSE) ;
        void        RunOneEvent(AliRawReader * rawReader) ; 
@@ -63,8 +63,8 @@ public:
        void        RunOneEvent(AliESDEvent *& esd)  ;
        Bool_t      Save2OCDB(const Int_t runNumber, AliRecoParam::EventSpecie_t es, const char * year = "08", const char * detectors = "ALL") const ; 
        void        SetActiveDetectors(TString aDet) { fDetectors = aDet ;  }
-       void        SetCycleLength(const AliQA::DETECTORINDEX_t det, const Int_t cycle) { fQACycles[det] = cycle ; }
-       void        SetWriteExpert(const AliQA::DETECTORINDEX_t det) { fQAWriteExpert[det] = kTRUE ; }
+       void        SetCycleLength(const AliQAv1::DETECTORINDEX_t det, const Int_t cycle) { fQACycles[det] = cycle ; }
+       void        SetWriteExpert(const AliQAv1::DETECTORINDEX_t det) { fQAWriteExpert[det] = kTRUE ; }
        void        SetEventRange(UInt_t first, UInt_t last) { fFirstEvent = first ; fMaxEvents = last - first + 1 ; }    
   void        SetEventSpecie(AliRecoParam::EventSpecie_t es) ; 
        void        SetFirsEvent(UInt_t first) { fFirstEvent = first ; }      
@@ -75,13 +75,13 @@ public:
        void        SetTasks(TString tasks) { fTasks = tasks ; }
   void        SetWriteExpert() ; 
 private: 
-       Bool_t                    DoIt(const AliQA::TASKINDEX_t taskIndex) ;
+       Bool_t                    DoIt(const AliQAv1::TASKINDEX_t taskIndex) ;
        AliLoader   * GetLoader(Int_t iDet) ; 
        Int_t         GetQACycles(const Int_t iDet) const { return fQACycles[iDet] ; }
-       Bool_t                    InitQA(const AliQA::TASKINDEX_t taskIndex, const  char * fileName = NULL) ;
+       Bool_t                    InitQA(const AliQAv1::TASKINDEX_t taskIndex, const  char * fileName = NULL) ;
        Bool_t        InitRunLoader() ; 
        Bool_t        IsSelected(const char * detName)  ;
-       Bool_t        Finish(const AliQA::TASKINDEX_t taskIndex) ;
+       Bool_t        Finish(const AliQAv1::TASKINDEX_t taskIndex) ;
        Bool_t        MergeData(const Int_t runNumber) const ;  
        Bool_t        MergeResults(const Int_t runNumber) const ;  
        Bool_t        SaveIt2OCDB(const Int_t runNumber, TFile * inputFile, const char * year, AliRecoParam::EventSpecie_t es) const ;  
@@ -104,7 +104,7 @@ private:
        Bool_t                  fRawReaderDelete ;              //! tells if the rawReader has been created by this
        AliRunLoader *          fRunLoader ;                    //! current run loader object
        TString                 fTasks ;                        //! list of QA tasks to be performed
-       static const UInt_t     fgkNDetectors = AliQA::kNDET ;  //! number of detectors    
+       static const UInt_t     fgkNDetectors = AliQAv1::kNDET ;  //! number of detectors    
        AliLoader      *        fLoader[fgkNDetectors];         //! array of detectors loader
        AliQADataMaker *        fQADataMaker[fgkNDetectors];    //! array of QA data maker objects
        Int_t                   fQACycles[fgkNDetectors];       //! array of QA cycle length
diff --git a/STEER/AliQAv1.cxx b/STEER/AliQAv1.cxx
new file mode 100644 (file)
index 0000000..6118e53
--- /dev/null
@@ -0,0 +1,836 @@
+
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+/* $Id: AliQAv1.cxx 31503 2009-03-16 11:01:16Z schutz $ */
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Quality Assurance Object//_________________________________________________________________________
+// Quality Assurance object. The QA status is held in one word per detector,
+// each bit corresponds to a different status.
+// bit 0-3   : QA raised during simulation      (RAW)
+// bit 4-7   : QA raised during simulation      (SIM)
+// bit 8-11  : QA raised during reconstruction  (REC)
+// bit 12-15 : QA raised during ESD checking    (ESD)
+// bit 16-19 : QA raised during analysis        (ANA)
+// Each of the 4 bits corresponds to a severity level of increasing importance
+// from lower to higher bit (INFO, WARNING, ERROR, FATAL)
+//
+//*-- Yves Schutz CERN, July 2007 
+//////////////////////////////////////////////////////////////////////////////
+
+
+#include <cstdlib>
+// --- ROOT system ---
+#include <TFile.h>
+#include <TSystem.h>
+#include <TROOT.h>
+
+// --- Standard library ---
+
+// --- AliRoot header files ---
+#include "AliLog.h"
+#include "AliQAv1.h"
+
+
+ClassImp(AliQAv1)
+AliQAv1    * AliQAv1::fgQA                   = 0x0 ;
+TFile    * AliQAv1::fgQADataFile           = 0x0 ;   
+TString    AliQAv1::fgQADataFileName       = "QA" ;  // will transform into Det.QA.run.root  
+TFile    * AliQAv1::fgQARefFile            = 0x0 ;   
+TString    AliQAv1::fgQARefDirName            = "" ; 
+TString    AliQAv1::fgQARefFileName        = "QA.root" ;
+TFile    * AliQAv1::fgQAResultFile         = 0x0 ;  
+TString    AliQAv1::fgQAResultDirName      = "" ;  
+TString    AliQAv1::fgQAResultFileName     = "QA.root" ; 
+TString    AliQAv1::fgDetNames[]           = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD",
+                                            "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT", "Global", "CORR"} ;   
+TString    AliQAv1::fgGRPPath              = "GRP/GRP/Data" ; 
+TString       AliQAv1::fgTaskNames[]       = {"Raws", "Hits", "SDigits", "Digits", "RecPoints", "TrackSegments", "RecParticles", "ESDs"} ;   
+const TString AliQAv1::fgkLabLocalFile     = "file://"  ; 
+const TString AliQAv1::fgkLabLocalOCDB     = "local://" ;  
+const TString AliQAv1::fgkLabAliEnOCDB     = "alien://" ;  
+const TString AliQAv1::fgkRefFileName      = "QA.root" ; 
+const TString AliQAv1::fgkQAName           = "QA"  ; 
+const TString AliQAv1::fgkQACorrNtName     = "CorrQA" ;  
+const TString AliQAv1::fgkRefOCDBDirName   = "QA"  ; 
+TString AliQAv1::fgRefDataDirName               = ""  ; 
+const TString AliQAv1::fgkQARefOCDBDefault = "alien://folder=/alice/QA/20"  ; 
+const TString AliQAv1::fgkExpert           = "Expert" ; 
+const UInt_t  AliQAv1::fgkExpertBit        = 16 ; 
+const UInt_t  AliQAv1::fgkQABit            = 17 ; 
+
+//____________________________________________________________________________
+AliQAv1::AliQAv1() : 
+  TNamed("", ""), 
+  fNdet(kNDET), 
+  fNEventSpecies(AliRecoParam::kNSpecies), 
+  fLengthQA(fNdet*fNEventSpecies),
+  fQA(new ULong_t[fLengthQA]), 
+  fDet(kNULLDET),
+  fTask(kNULLTASK), 
+  fEventSpecie(AliRecoParam::kDefault), 
+  fEventSpecies(new Bool_t[fNEventSpecies])
+{
+  // default constructor
+  memset(fQA,0,fLengthQA*sizeof(ULong_t));
+  memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+}
+
+//____________________________________________________________________________
+AliQAv1::AliQAv1(const AliQAv1& qa) :
+  TNamed(qa),
+  fNdet(qa.fNdet), 
+  fNEventSpecies(qa.fNEventSpecies), 
+  fLengthQA(qa.fLengthQA),
+  fQA(new ULong_t[fLengthQA]), 
+  fDet(qa.fDet),
+  fTask(qa.fTask), 
+  fEventSpecie(qa.fEventSpecie), 
+  fEventSpecies(new Bool_t[fNEventSpecies])
+{ 
+  // cpy ctor
+  memcpy(fQA,qa.fQA,fLengthQA*sizeof(ULong_t));
+  memcpy(fEventSpecies,qa.fEventSpecies,fNEventSpecies*sizeof(Bool_t));
+}
+
+//_____________________________________________________________________________
+AliQAv1& AliQAv1::operator = (const AliQAv1& qa)
+{
+  // assignment operator
+  if(&qa != this) {
+    TNamed::operator=(qa);
+    fNdet          = qa.fNdet;
+    fNEventSpecies = qa.fNEventSpecies; 
+    fLengthQA      = qa.fLengthQA;
+
+    if(fQA) delete [] fQA;
+    fQA = new ULong_t[fLengthQA];
+    memcpy(fQA,qa.fQA,fLengthQA*sizeof(ULong_t));
+
+    fDet = qa.fDet;
+    fTask = qa.fTask;
+    fEventSpecie = qa.fEventSpecie; 
+    if(fEventSpecies) delete [] fEventSpecies;
+    fEventSpecies = new Bool_t[fNEventSpecies];
+    memcpy(fEventSpecies,qa.fEventSpecies,fNEventSpecies*sizeof(Bool_t));
+  }  
+  return *this;
+}
+
+//_______________________________________________________________
+AliQAv1::AliQAv1(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es) :
+TNamed("QA", "Quality Assurance status"),
+fNdet(kNDET), 
+fNEventSpecies(eslength), 
+fLengthQA(qalength),
+fQA(new ULong_t[fLengthQA]), 
+fDet(kNULLDET),
+fTask(kNULLTASK), 
+fEventSpecie(AliRecoParam::kDefault), 
+fEventSpecies(new Bool_t[fNEventSpecies])
+{
+  // constructor to be used
+  memcpy(fQA, qa, fLengthQA*sizeof(ULong_t));
+  memcpy(fEventSpecies, es, fNEventSpecies*sizeof(Bool_t));
+}
+
+//_______________________________________________________________
+AliQAv1::AliQAv1(const DETECTORINDEX_t det) :
+  TNamed("QA", "Quality Assurance status"),
+  fNdet(kNDET), 
+  fNEventSpecies(AliRecoParam::kNSpecies), 
+  fLengthQA(fNdet*fNEventSpecies),
+  fQA(new ULong_t[fLengthQA]), 
+  fDet(det),
+  fTask(kNULLTASK), 
+  fEventSpecie(AliRecoParam::kDefault), 
+  fEventSpecies(new Bool_t[fNEventSpecies])
+{
+  // constructor to be used
+  if (! CheckRange(det) ) fDet = kNULLDET ; 
+  memset(fQA,0,fLengthQA*sizeof(ULong_t));
+  memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+}
+  
+//_______________________________________________________________
+AliQAv1::AliQAv1(const ALITASK_t tsk) :
+  TNamed("QA", "Quality Assurance status"),
+  fNdet(kNDET), 
+  fNEventSpecies(AliRecoParam::kNSpecies), 
+  fLengthQA(fNdet*fNEventSpecies),
+  fQA(new ULong_t[fLengthQA]), 
+  fDet(kNULLDET),
+  fTask(tsk), 
+  fEventSpecie(AliRecoParam::kDefault), 
+  fEventSpecies(new Bool_t[fNEventSpecies])
+{
+  // constructor to be used in the AliRoot module (SIM, REC, ESD or ANA)
+  if (! CheckRange(tsk) ) fTask = kNULLTASK ; 
+  memset(fQA,0,fLengthQA*sizeof(ULong_t));
+  memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+}
+
+//____________________________________________________________________________
+AliQAv1::~AliQAv1() 
+{
+  // dtor  
+  delete [] fQA;
+  delete [] fEventSpecies;
+}
+
+//_______________________________________________________________
+void AliQAv1::Close() 
+{
+       // close the open files
+       if (fgQADataFile) 
+               if (fgQADataFile->IsOpen())
+                       fgQADataFile->Close() ; 
+       if (fgQAResultFile) 
+               if (fgQAResultFile->IsOpen()) 
+                       fgQAResultFile->Close() ;
+       if (fgQARefFile)
+               if (fgQARefFile->IsOpen())
+                       fgQARefFile->Close() ; 
+} 
+
+//_______________________________________________________________
+Bool_t AliQAv1::CheckFatal() const
+{
+  // check if any FATAL status is set
+  Bool_t rv = kFALSE ;
+  Int_t index ;
+  for (index = 0; index < kNDET ; index++)
+    rv = rv || IsSet(DETECTORINDEX_t(index), fTask, fEventSpecie, kFATAL) ;
+  return rv ;
+}
+
+//_______________________________________________________________
+Bool_t AliQAv1::CheckRange(DETECTORINDEX_t det) const
+{ 
+  // check if detector is in given detector range: 0-kNDET
+
+  Bool_t rv = ( det < 0 || det > kNDET )  ? kFALSE : kTRUE ;
+  if (!rv)
+    AliFatal(Form("Detector index %d is out of range: 0 <= index <= %d", det, kNDET)) ;
+  return rv ;
+}
+
+//_______________________________________________________________
+Bool_t AliQAv1::CheckRange(ALITASK_t task) const
+{ 
+  // check if task is given taskk range: 0:kNTASK
+  Bool_t rv = ( task < kRAW || task > kNTASK )  ? kFALSE : kTRUE ;
+  if (!rv)
+    AliFatal(Form("Module index %d is out of range: 0 <= index <= %d", task, kNTASK)) ;
+  return rv ;
+}
+
+//_______________________________________________________________
+Bool_t AliQAv1::CheckRange(QABIT_t bit) const
+{ 
+  // check if bit is in given bit range: 0-kNBit
+
+  Bool_t rv = ( bit < 0 || bit > kNBIT )  ? kFALSE : kTRUE ;
+  if (!rv)
+    AliFatal(Form("Status bit %d is out of range: 0 <= bit <= %d", bit, kNBIT)) ;
+  return rv ;
+}
+
+//_______________________________________________________________
+Bool_t AliQAv1::CheckRange(AliRecoParam::EventSpecie_t es) const
+{ 
+  // check if bit is in given bit range: 0-kNBit
+  Bool_t rv = kFALSE ; 
+  switch (es) {
+    case AliRecoParam::kDefault: 
+      rv = kTRUE ; 
+      break ; 
+    case AliRecoParam::kLowMult: 
+      rv = kTRUE ; 
+      break ; 
+    case AliRecoParam::kHighMult: 
+      rv = kTRUE ; 
+      break ; 
+    case AliRecoParam::kCosmic: 
+      rv = kTRUE ; 
+      break ; 
+    case AliRecoParam::kCalib: 
+      rv = kTRUE ; 
+      break ; 
+  }
+  if (!rv)
+    AliFatal(Form("Event Specie %d is not valid", es)) ;
+  return rv ;
+}
+
+//_______________________________________________________________
+const char * AliQAv1::GetAliTaskName(ALITASK_t tsk)
+{
+       // returns the char name corresponding to module index
+       TString tskName ;
+       switch (tsk) {
+               case kNULLTASK:
+                       break ; 
+               case kRAW:
+                       tskName = "RAW" ;
+                       break ;  
+               case kSIM:
+                       tskName = "SIM" ;
+                       break ;
+               case kREC:
+                       tskName = "REC" ;
+                       break ;
+               case kESD:
+                       tskName = "ESD" ;
+                       break ;
+               case kANA:
+                       tskName = "ANA" ;
+                       break ;
+               default:
+                       tsk = kNULLTASK ; 
+                       break ;
+       }
+       return tskName.Data() ;
+}
+
+//_______________________________________________________________
+const char * AliQAv1::GetBitName(QABIT_t bit) const
+{
+       // returns the char name corresponding to bit 
+       TString bitName ;
+       switch (bit) {
+               case kNULLBit:
+                       break ; 
+               case kINFO:
+                       bitName = "INFO" ;
+                       break ;  
+               case kWARNING:
+                       bitName = "WARNING" ;
+                       break ;
+               case kERROR:
+                       bitName = "ERROR" ;
+                       break ;
+               case kFATAL:
+                       bitName = "FATAL" ;
+                       break ;
+               default:
+                       bit = kNULLBit ; 
+                       break ;
+       }
+       return bitName.Data() ;
+}
+
+//_______________________________________________________________
+AliQAv1::DETECTORINDEX_t AliQAv1::GetDetIndex(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 ;             
+}
+
+//_______________________________________________________________
+const char * AliQAv1::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 ; 
+}
+
+//_______________________________________________________________
+TFile * AliQAv1::GetQADataFile(const char * name, Int_t run) 
+{
+  // opens the file to store the detectors Quality Assurance Data Maker results
+       const char * temp = Form("%s.%s.%d.root", name, fgQADataFileName.Data(), run) ; 
+       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 ;
+} 
+
+//_____________________________________________________________________________
+TFile * AliQAv1::GetQADataFile(const char * fileName)
+{
+  // Open if necessary the Data file and return its pointer
+
+  if (!fgQADataFile) 
+       if (!fileName) 
+               fileName = AliQAv1::GetQADataFileName() ; 
+       if  (!gSystem->AccessPathName(fileName)) {
+               fgQADataFile =  TFile::Open(fileName) ;
+       } else {
+               printf("File %s not found", fileName) ;
+               exit(1) ;  
+       }
+  return fgQAD