From 48aa6f1b41ff94fb7bb0277135cc4e5b325aeb53 Mon Sep 17 00:00:00 2001
From: hristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Date: Thu, 7 May 2009 10:50:59 +0000
Subject: [PATCH] Fixes for bug #49914: Compilation breaks in trunk, and bug
 #48629: Trunk cannot read tag files produced by v4-16-Release. The old
 version of the classs AliQA is reintroduced, and the new version becomes
 AliQAv1 (Yves)

---
 ACORDE/AliACORDEQAChecker.cxx      |   8 +-
 ACORDE/AliACORDEQAChecker.h        |   4 +-
 ACORDE/AliACORDEQADataMaker.cxx    |   2 +-
 ACORDE/AliACORDEQADataMaker.h      |  12 +-
 ACORDE/AliACORDEQADataMakerRec.cxx |   6 +-
 ACORDE/AliACORDEQADataMakerRec.h   |   2 +-
 ACORDE/AliACORDEQADataMakerSim.cxx |   6 +-
 ACORDE/AliACORDEQADataMakerSim.h   |   2 +-
 EMCAL/AliEMCALQAChecker.cxx        |   2 +-
 EMCAL/AliEMCALQADataMakerRec.cxx   |   6 +-
 EMCAL/AliEMCALQADataMakerRec.h     |   2 +-
 EMCAL/AliEMCALQADataMakerSim.cxx   |   6 +-
 EMCAL/AliEMCALQADataMakerSim.h     |   2 +-
 FMD/AliFMDQAChecker.cxx            |   2 +-
 FMD/AliFMDQADataMakerRec.cxx       |   8 +-
 FMD/AliFMDQADataMakerRec.h         |   2 +-
 FMD/AliFMDQADataMakerSim.cxx       |   6 +-
 FMD/AliFMDQADataMakerSim.h         |   2 +-
 HMPID/AliHMPIDQAChecker.cxx        |  12 +-
 HMPID/AliHMPIDQAChecker.h          |   4 +-
 HMPID/AliHMPIDQADataMaker.cxx      |   6 +-
 HMPID/AliHMPIDQADataMaker.h        |   2 +-
 HMPID/AliHMPIDQADataMakerRec.cxx   |   8 +-
 HMPID/AliHMPIDQADataMakerRec.h     |   2 +-
 HMPID/AliHMPIDQADataMakerSim.cxx   |   6 +-
 HMPID/AliHMPIDQADataMakerSim.h     |   2 +-
 HMPID/AliHMPIDRawStream.cxx        |   2 +-
 ITS/AliITSQAChecker.cxx            |  14 +-
 ITS/AliITSQAChecker.h              |   6 +-
 ITS/AliITSQADataMakerRec.cxx       |  12 +-
 ITS/AliITSQADataMakerRec.h         |   4 +-
 ITS/AliITSQADataMakerSim.cxx       |  12 +-
 ITS/AliITSQADataMakerSim.h         |   4 +-
 ITS/AliITSQASDDChecker.cxx         |   8 +-
 ITS/AliITSQASDDChecker.h           |   4 +-
 ITS/AliITSQASDDDataMakerRec.cxx    |  18 +-
 ITS/AliITSQASDDDataMakerRec.h      |   8 +-
 ITS/AliITSQASDDDataMakerSim.cxx    |  24 +-
 ITS/AliITSQASDDDataMakerSim.h      |   8 +-
 ITS/AliITSQASPDChecker.cxx         |   2 +-
 ITS/AliITSQASPDChecker.h           |   4 +-
 ITS/AliITSQASPDDataMakerRec.cxx    |  20 +-
 ITS/AliITSQASPDDataMakerRec.h      |   8 +-
 ITS/AliITSQASPDDataMakerSim.cxx    |  24 +-
 ITS/AliITSQASPDDataMakerSim.h      |   8 +-
 ITS/AliITSQASSDChecker.cxx         |   2 +-
 ITS/AliITSQASSDChecker.h           |   4 +-
 ITS/AliITSQASSDDataMakerRec.cxx    |  20 +-
 ITS/AliITSQASSDDataMakerRec.h      |   8 +-
 ITS/AliITSQASSDDataMakerSim.cxx    |  24 +-
 ITS/AliITSQASSDDataMakerSim.h      |   8 +-
 MUON/AliMUONPadStatusMaker.cxx     |   4 +-
 MUON/AliMUONQAChecker.cxx          |  68 +--
 MUON/AliMUONQAChecker.h            |   8 +-
 MUON/AliMUONQADataMakerRec.cxx     |  30 +-
 MUON/AliMUONQADataMakerRec.h       |   6 +-
 MUON/AliMUONQADataMakerSim.cxx     |   6 +-
 MUON/AliMUONQADataMakerSim.h       |   2 +-
 MUON/Doxymodules_STEER.h           |   1 +
 MUON/runReconstruction.C           |   2 +-
 PHOS/AliPHOSQAChecker.cxx          |   2 +-
 PHOS/AliPHOSQADataMakerRec.cxx     |  14 +-
 PHOS/AliPHOSQADataMakerRec.h       |   2 +-
 PHOS/AliPHOSQADataMakerSim.cxx     |   6 +-
 PHOS/AliPHOSQADataMakerSim.h       |   2 +-
 PHOS/AliPHOSSDigitizer.cxx         |  26 +-
 PMD/AliPMDQAChecker.cxx            |   2 +-
 PMD/AliPMDQADataMakerRec.cxx       |   6 +-
 PMD/AliPMDQADataMakerRec.h         |   2 +-
 PMD/AliPMDQADataMakerSim.cxx       |   6 +-
 PMD/AliPMDQADataMakerSim.h         |   2 +-
 STEER/AliCorrQAChecker.cxx         |   6 +-
 STEER/AliCorrQAChecker.h           |   6 +-
 STEER/AliCorrQADataMakerRec.cxx    |  14 +-
 STEER/AliCorrQADataMakerRec.h      |   2 +-
 STEER/AliGlobalQAChecker.cxx       |   2 +-
 STEER/AliGlobalQADataMaker.cxx     |   4 +-
 STEER/AliGlobalQADataMaker.h       |   2 +-
 STEER/AliQA.cxx                    | 386 +++++--------
 STEER/AliQA.h                      | 235 ++++----
 STEER/AliQAChecker.cxx             | 170 +++---
 STEER/AliQAChecker.h               |   8 +-
 STEER/AliQACheckerBase.cxx         |  94 ++--
 STEER/AliQACheckerBase.h           |  14 +-
 STEER/AliQADataMaker.cxx           |  20 +-
 STEER/AliQADataMaker.h             |  16 +-
 STEER/AliQADataMakerRec.cxx        |  74 +--
 STEER/AliQADataMakerRec.h          |  14 +-
 STEER/AliQADataMakerSim.cxx        |  72 +--
 STEER/AliQADataMakerSim.h          |  12 +-
 STEER/AliQAManager.cxx             | 270 +++++-----
 STEER/AliQAManager.h               |  32 +-
 STEER/AliQAv1.cxx                  | 836 +++++++++++++++++++++++++++++
 STEER/AliQAv1.h                    | 153 ++++++
 STEER/AliReconstruction.cxx        |  80 +--
 STEER/AliReconstruction.h          |  10 +-
 STEER/AliSimulation.cxx            |  24 +-
 STEER/AliSimulation.h              |   6 +-
 STEER/CMake_libSTEER.txt           |   2 +-
 STEER/CMake_libSTEERBase.txt       |   1 +
 STEER/STEERBaseLinkDef.h           |   1 +
 STEER/STEERLinkDef.h               |   2 +-
 STEER/libSTEER.pkg                 |   2 +-
 STEER/libSTEERBase.pkg             |   2 +-
 T0/AliT0QAChecker.cxx              |   8 +-
 T0/AliT0QAChecker.h                |   4 +-
 T0/AliT0QADataMaker.cxx            |   6 +-
 T0/AliT0QADataMaker.h              |   2 +-
 T0/AliT0QADataMakerRec.cxx         |  10 +-
 T0/AliT0QADataMakerRec.h           |   2 +-
 T0/AliT0QADataMakerSim.cxx         |   6 +-
 T0/AliT0QADataMakerSim.h           |   2 +-
 TOF/AliTOFQAChecker.cxx            |   6 +-
 TOF/AliTOFQAChecker.h              |   6 +-
 TOF/AliTOFQADataMaker.cxx          |   6 +-
 TOF/AliTOFQADataMaker.h            |   2 +-
 TOF/AliTOFQADataMakerRec.cxx       |   6 +-
 TOF/AliTOFQADataMakerRec.h         |   2 +-
 TOF/AliTOFQADataMakerSim.cxx       |   6 +-
 TOF/AliTOFQADataMakerSim.h         |   2 +-
 TPC/AliTPCQADataMakerRec.cxx       |   8 +-
 TPC/AliTPCQADataMakerRec.h         |   2 +-
 TPC/AliTPCQADataMakerSim.cxx       |   6 +-
 TPC/AliTPCQADataMakerSim.h         |   2 +-
 TRD/AliTRDQAChecker.cxx            |   2 +-
 TRD/AliTRDQAChecker.h              |   8 +-
 TRD/AliTRDQADataMaker.cxx          |   8 +-
 TRD/AliTRDQADataMaker.h            |   2 +-
 TRD/AliTRDQADataMakerRec.cxx       |  10 +-
 TRD/AliTRDQADataMakerRec.h         |   2 +-
 TRD/AliTRDQADataMakerSim.cxx       |   6 +-
 TRD/AliTRDQADataMakerSim.h         |   2 +-
 TRD/AliTRDqaRecPoints.cxx          |   2 +-
 VZERO/AliVZEROQAChecker.cxx        |  64 +--
 VZERO/AliVZEROQAChecker.h          |   8 +-
 VZERO/AliVZEROQADataMakerRec.cxx   |  32 +-
 VZERO/AliVZEROQADataMakerRec.h     |   2 +-
 VZERO/AliVZEROQADataMakerSim.cxx   |   6 +-
 VZERO/AliVZEROQADataMakerSim.h     |   2 +-
 ZDC/AliZDCQAChecker.cxx            |  18 +-
 ZDC/AliZDCQAChecker.h              |   4 +-
 ZDC/AliZDCQADataMaker.cxx          |   6 +-
 ZDC/AliZDCQADataMaker.h            |   2 +-
 ZDC/AliZDCQADataMakerRec.cxx       |   6 +-
 ZDC/AliZDCQADataMakerRec.h         |   2 +-
 ZDC/AliZDCQADataMakerSim.cxx       |   6 +-
 ZDC/AliZDCQADataMakerSim.h         |   2 +-
 147 files changed, 2169 insertions(+), 1274 deletions(-)
 create mode 100644 STEER/AliQAv1.cxx
 create mode 100644 STEER/AliQAv1.h

diff --git a/ACORDE/AliACORDEQAChecker.cxx b/ACORDE/AliACORDEQAChecker.cxx
index d4008bbd67c..b8486de2dc4 100755
--- a/ACORDE/AliACORDEQAChecker.cxx
+++ b/ACORDE/AliACORDEQAChecker.cxx
@@ -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);
 
 
diff --git a/ACORDE/AliACORDEQAChecker.h b/ACORDE/AliACORDEQAChecker.h
index c2607f5e628..0d8f40388a5 100755
--- a/ACORDE/AliACORDEQAChecker.h
+++ b/ACORDE/AliACORDEQAChecker.h
@@ -30,8 +30,8 @@ class AliACORDEQAChecker: public AliQACheckerBase {
 //  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;
 
diff --git a/ACORDE/AliACORDEQADataMaker.cxx b/ACORDE/AliACORDEQADataMaker.cxx
index db8308f51da..2ab349fe0b0 100755
--- a/ACORDE/AliACORDEQADataMaker.cxx
+++ b/ACORDE/AliACORDEQADataMaker.cxx
@@ -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
 }
diff --git a/ACORDE/AliACORDEQADataMaker.h b/ACORDE/AliACORDEQADataMaker.h
index 98e19e7ea9e..9fb5b366955 100755
--- a/ACORDE/AliACORDEQADataMaker.h
+++ b/ACORDE/AliACORDEQADataMaker.h
@@ -51,8 +51,8 @@ class AliACORDEQADataMaker: public AliQADataMaker {
   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 @@ class AliACORDEQADataMaker: public AliQADataMaker {
   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*){};
diff --git a/ACORDE/AliACORDEQADataMakerRec.cxx b/ACORDE/AliACORDEQADataMakerRec.cxx
index acd8d9aed1c..3b785bf7fa6 100755
--- a/ACORDE/AliACORDEQADataMakerRec.cxx
+++ b/ACORDE/AliACORDEQADataMakerRec.cxx
@@ -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) ;
 }
 
 //____________________________________________________________________________
diff --git a/ACORDE/AliACORDEQADataMakerRec.h b/ACORDE/AliACORDEQADataMakerRec.h
index 109a1e36c14..606527ad5eb 100755
--- a/ACORDE/AliACORDEQADataMakerRec.h
+++ b/ACORDE/AliACORDEQADataMakerRec.h
@@ -42,7 +42,7 @@ class AliACORDEQADataMakerRec: public AliQADataMakerRec {
   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 
 
diff --git a/ACORDE/AliACORDEQADataMakerSim.cxx b/ACORDE/AliACORDEQADataMakerSim.cxx
index b4afb680fa9..6ebe597a1cf 100755
--- a/ACORDE/AliACORDEQADataMakerSim.cxx
+++ b/ACORDE/AliACORDEQADataMakerSim.cxx
@@ -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()
diff --git a/ACORDE/AliACORDEQADataMakerSim.h b/ACORDE/AliACORDEQADataMakerSim.h
index 5b92771c1fb..96483f623fa 100755
--- a/ACORDE/AliACORDEQADataMakerSim.h
+++ b/ACORDE/AliACORDEQADataMakerSim.h
@@ -43,7 +43,7 @@ class AliACORDEQADataMakerSim: public AliQADataMakerSim {
   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 
 
diff --git a/EMCAL/AliEMCALQAChecker.cxx b/EMCAL/AliEMCALQAChecker.cxx
index 519e7b88b31..d032630f548 100644
--- a/EMCAL/AliEMCALQAChecker.cxx
+++ b/EMCAL/AliEMCALQAChecker.cxx
@@ -33,7 +33,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliEMCALQAChecker.h"
 
diff --git a/EMCAL/AliEMCALQADataMakerRec.cxx b/EMCAL/AliEMCALQADataMakerRec.cxx
index 665a601c121..03ecd6f4ce4 100644
--- a/EMCAL/AliEMCALQADataMakerRec.cxx
+++ b/EMCAL/AliEMCALQADataMakerRec.cxx
@@ -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) ;  
 }
 
 //____________________________________________________________________________ 
diff --git a/EMCAL/AliEMCALQADataMakerRec.h b/EMCAL/AliEMCALQADataMakerRec.h
index 4170d11149f..f89dd75e5d9 100644
--- a/EMCAL/AliEMCALQADataMakerRec.h
+++ b/EMCAL/AliEMCALQADataMakerRec.h
@@ -44,7 +44,7 @@ class AliEMCALQADataMakerRec: public AliQADataMakerRec {
   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() ; 
diff --git a/EMCAL/AliEMCALQADataMakerSim.cxx b/EMCAL/AliEMCALQADataMakerSim.cxx
index c0a973a5d6a..30a2e3d45fc 100644
--- a/EMCAL/AliEMCALQADataMakerSim.cxx
+++ b/EMCAL/AliEMCALQADataMakerSim.cxx
@@ -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) ;  
 }
 
 //____________________________________________________________________________ 
diff --git a/EMCAL/AliEMCALQADataMakerSim.h b/EMCAL/AliEMCALQADataMakerSim.h
index ea808474e23..2fc4f282033 100644
--- a/EMCAL/AliEMCALQADataMakerSim.h
+++ b/EMCAL/AliEMCALQADataMakerSim.h
@@ -31,7 +31,7 @@ class AliEMCALQADataMakerSim: public AliQADataMakerSim {
   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() ; 
diff --git a/FMD/AliFMDQAChecker.cxx b/FMD/AliFMDQAChecker.cxx
index ad49e67a349..a695130c151 100644
--- a/FMD/AliFMDQAChecker.cxx
+++ b/FMD/AliFMDQAChecker.cxx
@@ -34,7 +34,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliFMDQAChecker.h"
 
diff --git a/FMD/AliFMDQADataMakerRec.cxx b/FMD/AliFMDQADataMakerRec.cxx
index ff36304b236..7bab9632e58 100644
--- a/FMD/AliFMDQADataMakerRec.cxx
+++ b/FMD/AliFMDQADataMakerRec.cxx
@@ -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);
 }
 
 //_____________________________________________________________________ 
diff --git a/FMD/AliFMDQADataMakerRec.h b/FMD/AliFMDQADataMakerRec.h
index d15dc8956ff..58898d4632f 100644
--- a/FMD/AliFMDQADataMakerRec.h
+++ b/FMD/AliFMDQADataMakerRec.h
@@ -26,7 +26,7 @@ class AliFMDQADataMakerRec: public AliQADataMakerRec
   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(); 
diff --git a/FMD/AliFMDQADataMakerSim.cxx b/FMD/AliFMDQADataMakerSim.cxx
index df3f81cd4c0..39c768002f1 100644
--- a/FMD/AliFMDQADataMakerSim.cxx
+++ b/FMD/AliFMDQADataMakerSim.cxx
@@ -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) ;  
   
 }
 //_____________________________________________________________________
diff --git a/FMD/AliFMDQADataMakerSim.h b/FMD/AliFMDQADataMakerSim.h
index 20385718abd..951608cbdca 100644
--- a/FMD/AliFMDQADataMakerSim.h
+++ b/FMD/AliFMDQADataMakerSim.h
@@ -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() ; 
diff --git a/HMPID/AliHMPIDQAChecker.cxx b/HMPID/AliHMPIDQAChecker.cxx
index 7648ef1b39f..25d398e576e 100644
--- a/HMPID/AliHMPIDQAChecker.cxx
+++ b/HMPID/AliHMPIDQAChecker.cxx
@@ -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 
diff --git a/HMPID/AliHMPIDQAChecker.h b/HMPID/AliHMPIDQAChecker.h
index 73182e187c2..f07973e2f42 100644
--- a/HMPID/AliHMPIDQAChecker.h
+++ b/HMPID/AliHMPIDQAChecker.h
@@ -30,8 +30,8 @@ class AliHMPIDQAChecker: public AliQACheckerBase {
   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 ;
diff --git a/HMPID/AliHMPIDQADataMaker.cxx b/HMPID/AliHMPIDQADataMaker.cxx
index 991e05d273c..a50547eb307 100644
--- a/HMPID/AliHMPIDQADataMaker.cxx
+++ b/HMPID/AliHMPIDQADataMaker.cxx
@@ -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) ;  
 }
 
diff --git a/HMPID/AliHMPIDQADataMaker.h b/HMPID/AliHMPIDQADataMaker.h
index 0146d4c9235..07355d6dcfd 100644
--- a/HMPID/AliHMPIDQADataMaker.h
+++ b/HMPID/AliHMPIDQADataMaker.h
@@ -36,7 +36,7 @@ class AliHMPIDQADataMaker: public AliQADataMaker {
 
 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
diff --git a/HMPID/AliHMPIDQADataMakerRec.cxx b/HMPID/AliHMPIDQADataMakerRec.cxx
index 63a64d8af5e..4f1bb1715a4 100644
--- a/HMPID/AliHMPIDQADataMakerRec.cxx
+++ b/HMPID/AliHMPIDQADataMakerRec.cxx
@@ -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);
 
 }
 
diff --git a/HMPID/AliHMPIDQADataMakerRec.h b/HMPID/AliHMPIDQADataMakerRec.h
index 0f4fdad19d2..bcae699bab3 100644
--- a/HMPID/AliHMPIDQADataMakerRec.h
+++ b/HMPID/AliHMPIDQADataMakerRec.h
@@ -37,7 +37,7 @@ class AliHMPIDQADataMakerRec: public AliQADataMakerRec {
   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 
diff --git a/HMPID/AliHMPIDQADataMakerSim.cxx b/HMPID/AliHMPIDQADataMakerSim.cxx
index ac1e1b5f8aa..677626806a8 100644
--- a/HMPID/AliHMPIDQADataMakerSim.cxx
+++ b/HMPID/AliHMPIDQADataMakerSim.cxx
@@ -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) ;  
 }
 
diff --git a/HMPID/AliHMPIDQADataMakerSim.h b/HMPID/AliHMPIDQADataMakerSim.h
index ca1c5814e4c..998604786e0 100644
--- a/HMPID/AliHMPIDQADataMakerSim.h
+++ b/HMPID/AliHMPIDQADataMakerSim.h
@@ -35,7 +35,7 @@ class AliHMPIDQADataMakerSim: public AliQADataMakerSim {
 
 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
diff --git a/HMPID/AliHMPIDRawStream.cxx b/HMPID/AliHMPIDRawStream.cxx
index 45c528bbbb0..1b01269dbfd 100644
--- a/HMPID/AliHMPIDRawStream.cxx
+++ b/HMPID/AliHMPIDRawStream.cxx
@@ -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;
diff --git a/ITS/AliITSQAChecker.cxx b/ITS/AliITSQAChecker.cxx
index 2b11813dff3..2f5ec93af51 100644
--- a/ITS/AliITSQAChecker.cxx
+++ b/ITS/AliITSQAChecker.cxx
@@ -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;  
       }
diff --git a/ITS/AliITSQAChecker.h b/ITS/AliITSQAChecker.h
index 48a17ab198b..daa079200b8 100644
--- a/ITS/AliITSQAChecker.h
+++ b/ITS/AliITSQAChecker.h
@@ -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 @@ friend class AliITSQASSDChecker;
   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;} ;
diff --git a/ITS/AliITSQADataMakerRec.cxx b/ITS/AliITSQADataMakerRec.cxx
index 78dc3271db6..e80251d9097 100644
--- a/ITS/AliITSQADataMakerRec.cxx
+++ b/ITS/AliITSQADataMakerRec.cxx
@@ -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)
     {
diff --git a/ITS/AliITSQADataMakerRec.h b/ITS/AliITSQADataMakerRec.h
index fe25b7da653..a8948d009a8 100644
--- a/ITS/AliITSQADataMakerRec.h
+++ b/ITS/AliITSQADataMakerRec.h
@@ -36,7 +36,7 @@ friend class AliITSQASSDDataMakerRec;
   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 @@ friend class AliITSQASSDDataMakerRec;
   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:
diff --git a/ITS/AliITSQADataMakerSim.cxx b/ITS/AliITSQADataMakerSim.cxx
index 1e2f65aaa36..6035f93d016 100644
--- a/ITS/AliITSQADataMakerSim.cxx
+++ b/ITS/AliITSQADataMakerSim.cxx
@@ -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)
     {
diff --git a/ITS/AliITSQADataMakerSim.h b/ITS/AliITSQADataMakerSim.h
index a2448d0d90d..8bf2d1672d3 100644
--- a/ITS/AliITSQADataMakerSim.h
+++ b/ITS/AliITSQADataMakerSim.h
@@ -31,7 +31,7 @@ friend class AliITSQASSDDataMakerSim;
   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 @@ friend class AliITSQASSDDataMakerSim;
   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:
 
diff --git a/ITS/AliITSQASDDChecker.cxx b/ITS/AliITSQASDDChecker.cxx
index bee0be9c176..ac88b74341e 100644
--- a/ITS/AliITSQASDDChecker.cxx
+++ b/ITS/AliITSQASDDChecker.cxx
@@ -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
diff --git a/ITS/AliITSQASDDChecker.h b/ITS/AliITSQASDDChecker.h
index 020d3f19c93..3e2a3da91b2 100644
--- a/ITS/AliITSQASDDChecker.h
+++ b/ITS/AliITSQASDDChecker.h
@@ -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 @@ class AliITSQASDDChecker: public TObject {
   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:
diff --git a/ITS/AliITSQASDDDataMakerRec.cxx b/ITS/AliITSQASDDDataMakerRec.cxx
index 6ee9494305b..a13d82fb695 100644
--- a/ITS/AliITSQASDDDataMakerRec.cxx
+++ b/ITS/AliITSQASDDDataMakerRec.cxx
@@ -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;   
       }
diff --git a/ITS/AliITSQASDDDataMakerRec.h b/ITS/AliITSQASDDDataMakerRec.h
index 8462171aec9..4f56534e6a7 100644
--- a/ITS/AliITSQASDDDataMakerRec.h
+++ b/ITS/AliITSQASDDDataMakerRec.h
@@ -14,7 +14,7 @@
 
 /* $Id$ */
 
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliITSQADataMakerRec.h"
 
 class TObjArray;
@@ -31,12 +31,12 @@ class AliITSQASDDDataMakerRec: public TObject {
   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;};
diff --git a/ITS/AliITSQASDDDataMakerSim.cxx b/ITS/AliITSQASDDDataMakerSim.cxx
index cd2e25d777c..2e63f2bab82 100644
--- a/ITS/AliITSQASDDDataMakerSim.cxx
+++ b/ITS/AliITSQASDDDataMakerSim.cxx
@@ -30,7 +30,7 @@
 // --- AliRoot header files ---
 #include "AliITSQASDDDataMakerSim.h"
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliQADataMakerSim.h"
 #include "AliITSQADataMakerSim.h"
@@ -94,11 +94,11 @@ void AliITSQASDDDataMakerSim::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliITSQASDDDataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TObjArray* /*list*/)
+void AliITSQASDDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)
 {
   // launch the QA checking
-  AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); 
-  //AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
+  AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n"); 
+  //AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);
 }
 
 //____________________________________________________________________________ 
@@ -298,16 +298,16 @@ void AliITSQASDDDataMakerSim::MakeHits(TTree * hits)
 
 //_______________________________________________________________
 
-Int_t AliITSQASDDDataMakerSim::GetOffset(AliQA::TASKINDEX_t task){
+Int_t AliITSQASDDDataMakerSim::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 {
@@ -320,16 +320,16 @@ Int_t AliITSQASDDDataMakerSim::GetOffset(AliQA::TASKINDEX_t task){
 
 //_______________________________________________________________
 
-Int_t AliITSQASDDDataMakerSim::GetTaskHisto(AliQA::TASKINDEX_t task) {
+Int_t AliITSQASDDDataMakerSim::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=fSDDhHTask ;  
   }
-  else if( task == AliQA::kSDIGITS) {
+  else if( task == AliQAv1::kSDIGITS) {
     histotot=fSDDhSTask;   
   }
-  else if( task == AliQA::kDIGITS) {
+  else if( task == AliQAv1::kDIGITS) {
     histotot=fSDDhDTask ;   
   }
   else {
diff --git a/ITS/AliITSQASDDDataMakerSim.h b/ITS/AliITSQASDDDataMakerSim.h
index a8de8f4d66c..eb064b44bd6 100644
--- a/ITS/AliITSQASDDDataMakerSim.h
+++ b/ITS/AliITSQASDDDataMakerSim.h
@@ -14,7 +14,7 @@
 
 /* $Id$ */
 
-#include "AliQA.h"
+#include "AliQAv1.h"
 class AliITSQADataMakerSim;
 class AliRunLoader;
 class AliRun;
@@ -29,7 +29,7 @@ class AliITSQASDDDataMakerSim : public TObject {
   AliITSQASDDDataMakerSim& operator = (const AliITSQASDDDataMakerSim& qac);
 
   virtual void StartOfDetectorCycle();
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);
+  virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
   virtual ~AliITSQASDDDataMakerSim() {;}   // dtor
   virtual void InitDigits();
   virtual void InitSDigits();
@@ -40,8 +40,8 @@ class AliITSQASDDDataMakerSim : public TObject {
   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:
 
diff --git a/ITS/AliITSQASPDChecker.cxx b/ITS/AliITSQASPDChecker.cxx
index 127031925b3..7b3ecbc4f9a 100644
--- a/ITS/AliITSQASPDChecker.cxx
+++ b/ITS/AliITSQASPDChecker.cxx
@@ -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));
 
diff --git a/ITS/AliITSQASPDChecker.h b/ITS/AliITSQASPDChecker.h
index d5b2890cb55..e5a5484ee56 100644
--- a/ITS/AliITSQASPDChecker.h
+++ b/ITS/AliITSQASPDChecker.h
@@ -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 @@ class AliITSQASPDChecker: public TObject {
   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:
   
diff --git a/ITS/AliITSQASPDDataMakerRec.cxx b/ITS/AliITSQASPDDataMakerRec.cxx
index 2c05aca2233..ae9647406ce 100644
--- a/ITS/AliITSQASPDDataMakerRec.cxx
+++ b/ITS/AliITSQASPDDataMakerRec.cxx
@@ -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 {
diff --git a/ITS/AliITSQASPDDataMakerRec.h b/ITS/AliITSQASPDDataMakerRec.h
index 5720972bbf5..86ed2134367 100644
--- a/ITS/AliITSQASPDDataMakerRec.h
+++ b/ITS/AliITSQASPDDataMakerRec.h
@@ -19,7 +19,7 @@ class TObjArray;
 class AliRawReader;
 class AliITSRawStreamSPDErrorLog;
 class AliITSQADataMakerRec;
-class AliQA;
+class AliQAv1;
 
 class AliITSQASPDDataMakerRec : public TObject {
 
@@ -33,10 +33,10 @@ class AliITSQASPDDataMakerRec : public TObject {
   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: 
 
diff --git a/ITS/AliITSQASPDDataMakerSim.cxx b/ITS/AliITSQASPDDataMakerSim.cxx
index 221cf7f96ad..5b9c2876973 100644
--- a/ITS/AliITSQASPDDataMakerSim.cxx
+++ b/ITS/AliITSQASPDDataMakerSim.cxx
@@ -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 {
diff --git a/ITS/AliITSQASPDDataMakerSim.h b/ITS/AliITSQASPDDataMakerSim.h
index 7687909f835..c7833790f68 100644
--- a/ITS/AliITSQASPDDataMakerSim.h
+++ b/ITS/AliITSQASPDDataMakerSim.h
@@ -16,7 +16,7 @@
 
 /* $Id$ */
 
-#include "AliQA.h"
+#include "AliQAv1.h"
 class AliITSQADataMakerSim;
 class TObjArray;
 class TClonesArray;
@@ -29,7 +29,7 @@ class AliITSQASPDDataMakerSim : public TObject {
   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 @@ class AliITSQASPDDataMakerSim : public TObject {
   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; }
diff --git a/ITS/AliITSQASSDChecker.cxx b/ITS/AliITSQASSDChecker.cxx
index a083e5156fb..11df668e763 100644
--- a/ITS/AliITSQASSDChecker.cxx
+++ b/ITS/AliITSQASSDChecker.cxx
@@ -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  ;
diff --git a/ITS/AliITSQASSDChecker.h b/ITS/AliITSQASSDChecker.h
index c4b8906c4bc..3bd80b3943c 100644
--- a/ITS/AliITSQASSDChecker.h
+++ b/ITS/AliITSQASSDChecker.h
@@ -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 @@ class AliITSQASSDChecker: public TObject {
   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);
 
 
diff --git a/ITS/AliITSQASSDDataMakerRec.cxx b/ITS/AliITSQASSDDataMakerRec.cxx
index caf4a570692..b553c315991 100644
--- a/ITS/AliITSQASSDDataMakerRec.cxx
+++ b/ITS/AliITSQASSDDataMakerRec.cxx
@@ -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 { 
diff --git a/ITS/AliITSQASSDDataMakerRec.h b/ITS/AliITSQASSDDataMakerRec.h
index 1a83f33d5f6..e65d14c196b 100644
--- a/ITS/AliITSQASSDDataMakerRec.h
+++ b/ITS/AliITSQASSDDataMakerRec.h
@@ -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 @@ class AliITSQASSDDataMakerRec: public TObject {
   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:
 
diff --git a/ITS/AliITSQASSDDataMakerSim.cxx b/ITS/AliITSQASSDDataMakerSim.cxx
index f7a810b77e9..93b0f686acf 100644
--- a/ITS/AliITSQASSDDataMakerSim.cxx
+++ b/ITS/AliITSQASSDDataMakerSim.cxx
@@ -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 {
diff --git a/ITS/AliITSQASSDDataMakerSim.h b/ITS/AliITSQASSDDataMakerSim.h
index 257aaf16f0f..42e389ea10c 100644
--- a/ITS/AliITSQASSDDataMakerSim.h
+++ b/ITS/AliITSQASSDDataMakerSim.h
@@ -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 @@ class AliITSQASSDDataMakerSim : public TObject {
   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 @@ class AliITSQASSDDataMakerSim : public TObject {
   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:
 
diff --git a/MUON/AliMUONPadStatusMaker.cxx b/MUON/AliMUONPadStatusMaker.cxx
index accac679588..6e038b223fe 100644
--- a/MUON/AliMUONPadStatusMaker.cxx
+++ b/MUON/AliMUONPadStatusMaker.cxx
@@ -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()));
diff --git a/MUON/AliMUONQAChecker.cxx b/MUON/AliMUONQAChecker.cxx
index 51243c62466..d694a65dbaa 100644
--- a/MUON/AliMUONQAChecker.cxx
+++ b/MUON/AliMUONQAChecker.cxx
@@ -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) ; 	
     }
   }
 }
diff --git a/MUON/AliMUONQAChecker.h b/MUON/AliMUONQAChecker.h
index 58592437c03..2c6a07b52df 100644
--- a/MUON/AliMUONQAChecker.h
+++ b/MUON/AliMUONQAChecker.h
@@ -24,15 +24,15 @@ class AliMUONQAChecker: public AliQACheckerBase {
   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);
diff --git a/MUON/AliMUONQADataMakerRec.cxx b/MUON/AliMUONQADataMakerRec.cxx
index 5b9cec41f9b..b343c9f10eb 100644
--- a/MUON/AliMUONQADataMakerRec.cxx
+++ b/MUON/AliMUONQADataMakerRec.cxx
@@ -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);
diff --git a/MUON/AliMUONQADataMakerRec.h b/MUON/AliMUONQADataMakerRec.h
index 87881efbf9b..29407d9ab1c 100644
--- a/MUON/AliMUONQADataMakerRec.h
+++ b/MUON/AliMUONQADataMakerRec.h
@@ -43,9 +43,9 @@ class AliMUONQADataMakerRec: public AliQADataMakerRec {
   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 @@ class AliMUONQADataMakerRec: public AliQADataMakerRec {
 private:
 	
   void Ctor();
-  void DisplayTriggerInfo(AliQA::TASKINDEX_t task);
+  void DisplayTriggerInfo(AliQAv1::TASKINDEX_t task);
   Bool_t FillTriggerDCSHistos();
   void InitRecPointsTracker();
   void InitRecPointsTrigger();
diff --git a/MUON/AliMUONQADataMakerSim.cxx b/MUON/AliMUONQADataMakerSim.cxx
index 3205048fae4..fb859cc4ead 100644
--- a/MUON/AliMUONQADataMakerSim.cxx
+++ b/MUON/AliMUONQADataMakerSim.cxx
@@ -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) ;  
 }
 
 
diff --git a/MUON/AliMUONQADataMakerSim.h b/MUON/AliMUONQADataMakerSim.h
index 53079a817c8..eafdcad7ee8 100644
--- a/MUON/AliMUONQADataMakerSim.h
+++ b/MUON/AliMUONQADataMakerSim.h
@@ -50,7 +50,7 @@ class AliMUONQADataMakerSim: public AliQADataMakerSim {
       /// 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
diff --git a/MUON/Doxymodules_STEER.h b/MUON/Doxymodules_STEER.h
index dc2471ec923..dcd4cb11bb0 100644
--- a/MUON/Doxymodules_STEER.h
+++ b/MUON/Doxymodules_STEER.h
@@ -217,6 +217,7 @@
     class AliGRPObject {};
 
     class AliQA {};
+    class AliQAv1 {};
 
     class AliRunInfo {};
     class AliEventInfo {};
diff --git a/MUON/runReconstruction.C b/MUON/runReconstruction.C
index 15455fd0d6d..d413462cb60 100644
--- a/MUON/runReconstruction.C
+++ b/MUON/runReconstruction.C
@@ -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();
diff --git a/PHOS/AliPHOSQAChecker.cxx b/PHOS/AliPHOSQAChecker.cxx
index 8332deb0b78..10e9b035111 100644
--- a/PHOS/AliPHOSQAChecker.cxx
+++ b/PHOS/AliPHOSQAChecker.cxx
@@ -34,7 +34,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliPHOSQAChecker.h"
 
diff --git a/PHOS/AliPHOSQADataMakerRec.cxx b/PHOS/AliPHOSQADataMakerRec.cxx
index ed9eceff2d4..9b5057c47cb 100644
--- a/PHOS/AliPHOSQADataMakerRec.cxx
+++ b/PHOS/AliPHOSQADataMakerRec.cxx
@@ -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) ; 
 }
 //____________________________________________________________________________
diff --git a/PHOS/AliPHOSQADataMakerRec.h b/PHOS/AliPHOSQADataMakerRec.h
index 12d937b4abe..5401af142f0 100644
--- a/PHOS/AliPHOSQADataMakerRec.h
+++ b/PHOS/AliPHOSQADataMakerRec.h
@@ -54,7 +54,7 @@ class AliPHOSQADataMakerRec: public AliQADataMakerRec {
 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() ; 
diff --git a/PHOS/AliPHOSQADataMakerSim.cxx b/PHOS/AliPHOSQADataMakerSim.cxx
index 613df7760ee..963bae7be03 100644
--- a/PHOS/AliPHOSQADataMakerSim.cxx
+++ b/PHOS/AliPHOSQADataMakerSim.cxx
@@ -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) ;  
 }
 
 //____________________________________________________________________________ 
diff --git a/PHOS/AliPHOSQADataMakerSim.h b/PHOS/AliPHOSQADataMakerSim.h
index 854a9eb95e6..ffe05d6a088 100644
--- a/PHOS/AliPHOSQADataMakerSim.h
+++ b/PHOS/AliPHOSQADataMakerSim.h
@@ -36,7 +36,7 @@ class AliPHOSQADataMakerSim: public AliQADataMakerSim {
   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() ; 
diff --git a/PHOS/AliPHOSSDigitizer.cxx b/PHOS/AliPHOSSDigitizer.cxx
index e5bbb1010f0..78fe69dc90c 100644
--- a/PHOS/AliPHOSSDigitizer.cxx
+++ b/PHOS/AliPHOSSDigitizer.cxx
@@ -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();
diff --git a/PMD/AliPMDQAChecker.cxx b/PMD/AliPMDQAChecker.cxx
index f2eb59c5918..548de49179b 100644
--- a/PMD/AliPMDQAChecker.cxx
+++ b/PMD/AliPMDQAChecker.cxx
@@ -31,7 +31,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliPMDQAChecker.h"
 
diff --git a/PMD/AliPMDQADataMakerRec.cxx b/PMD/AliPMDQADataMakerRec.cxx
index 7cedd07ebd1..0fbdf949fdf 100644
--- a/PMD/AliPMDQADataMakerRec.cxx
+++ b/PMD/AliPMDQADataMakerRec.cxx
@@ -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) ;  
 }
diff --git a/PMD/AliPMDQADataMakerRec.h b/PMD/AliPMDQADataMakerRec.h
index aae8b3b97df..4bbe0746665 100644
--- a/PMD/AliPMDQADataMakerRec.h
+++ b/PMD/AliPMDQADataMakerRec.h
@@ -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 
 
diff --git a/PMD/AliPMDQADataMakerSim.cxx b/PMD/AliPMDQADataMakerSim.cxx
index ab08b03fc1c..81c1918b206 100644
--- a/PMD/AliPMDQADataMakerSim.cxx
+++ b/PMD/AliPMDQADataMakerSim.cxx
@@ -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) ;  
 }
diff --git a/PMD/AliPMDQADataMakerSim.h b/PMD/AliPMDQADataMakerSim.h
index 273400721e6..03ce0debb05 100644
--- a/PMD/AliPMDQADataMakerSim.h
+++ b/PMD/AliPMDQADataMakerSim.h
@@ -41,7 +41,7 @@ class AliPMDQADataMakerSim: public AliQADataMakerSim {
   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 
diff --git a/STEER/AliCorrQAChecker.cxx b/STEER/AliCorrQAChecker.cxx
index dda4f9f873d..68a82dc7a42 100644
--- a/STEER/AliCorrQAChecker.cxx
+++ b/STEER/AliCorrQAChecker.cxx
@@ -35,14 +35,14 @@
 
 // --- 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. ; 
diff --git a/STEER/AliCorrQAChecker.h b/STEER/AliCorrQAChecker.h
index d1cb14f14c6..553e0004c2d 100644
--- a/STEER/AliCorrQAChecker.h
+++ b/STEER/AliCorrQAChecker.h
@@ -31,9 +31,9 @@ class AliCorrQAChecker: public AliQACheckerBase {
   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:
   
diff --git a/STEER/AliCorrQADataMakerRec.cxx b/STEER/AliCorrQADataMakerRec.cxx
index e3c46e6e9ed..ca0653175f6 100644
--- a/STEER/AliCorrQADataMakerRec.cxx
+++ b/STEER/AliCorrQADataMakerRec.cxx
@@ -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 ;
diff --git a/STEER/AliCorrQADataMakerRec.h b/STEER/AliCorrQADataMakerRec.h
index 69349ebef7e..f1d6855ecaf 100644
--- a/STEER/AliCorrQADataMakerRec.h
+++ b/STEER/AliCorrQADataMakerRec.h
@@ -33,7 +33,7 @@ class AliCorrQADataMakerRec: public AliQADataMakerRec {
   
 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() ; 
diff --git a/STEER/AliGlobalQAChecker.cxx b/STEER/AliGlobalQAChecker.cxx
index 03df1acd56c..107e8cb9361 100644
--- a/STEER/AliGlobalQAChecker.cxx
+++ b/STEER/AliGlobalQAChecker.cxx
@@ -34,7 +34,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliGlobalQAChecker.h"
 
diff --git a/STEER/AliGlobalQADataMaker.cxx b/STEER/AliGlobalQADataMaker.cxx
index 3aed4c06208..6b808f21adf 100644
--- a/STEER/AliGlobalQADataMaker.cxx
+++ b/STEER/AliGlobalQADataMaker.cxx
@@ -18,11 +18,11 @@
 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) ;  
 }
 
 //____________________________________________________________________________ 
diff --git a/STEER/AliGlobalQADataMaker.h b/STEER/AliGlobalQADataMaker.h
index ef8478c78a2..99e615d61a1 100644
--- a/STEER/AliGlobalQADataMaker.h
+++ b/STEER/AliGlobalQADataMaker.h
@@ -28,7 +28,7 @@ class AliGlobalQADataMaker: public AliQADataMakerRec {
 	AliQADataMakerRec(qadm) {;}
 
 private:
-	void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+	void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
 
 	void InitRaws(); 
 	void InitRecPoints();
diff --git a/STEER/AliQA.cxx b/STEER/AliQA.cxx
index 47365f1c0df..c24360d8178 100644
--- a/STEER/AliQA.cxx
+++ b/STEER/AliQA.cxx
@@ -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) )
@@ -429,6 +373,25 @@ TFile * AliQA::GetQAResultFile()
 	return fgQAResultFile ;
 }
 
+//_______________________________________________________________
+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) 
 {
@@ -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) ; 
@@ -705,6 +623,27 @@ void AliQA::SetQARefStorage(const char * name)
 	printf("AliQA::SetQARefDir: QA references are in  %s\n", tmp.Data() ) ;
 }
 
+//_____________________________________________________________________________
+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)
 {
@@ -712,64 +651,45 @@ void AliQA::SetQAResultDirName(const char * name)
 
   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
diff --git a/STEER/AliQA.h b/STEER/AliQA.h
index 3708fad77c1..d3acdae3b47 100644
--- a/STEER/AliQA.h
+++ b/STEER/AliQA.h
@@ -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$ */
 
@@ -10,144 +10,135 @@
 //
 
 #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
diff --git a/STEER/AliQAChecker.cxx b/STEER/AliQAChecker.cxx
index 9c7256ab997..d53c8c5991d 100644
--- a/STEER/AliQAChecker.cxx
+++ b/STEER/AliQAChecker.cxx
@@ -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 ; 
diff --git a/STEER/AliQAChecker.h b/STEER/AliQAChecker.h
index 11fddce85fc..e17e237a17d 100644
--- a/STEER/AliQAChecker.h
+++ b/STEER/AliQAChecker.h
@@ -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 @@ class AliQAChecker: public TNamed {
 //  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 @@ class AliQAChecker: public TNamed {
   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
 };
diff --git a/STEER/AliQACheckerBase.cxx b/STEER/AliQACheckerBase.cxx
index 07a23c8a303..cfaf9801597 100644
--- a/STEER/AliQACheckerBase.cxx
+++ b/STEER/AliQACheckerBase.cxx
@@ -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) ; 	
     }
   }
 }
diff --git a/STEER/AliQACheckerBase.h b/STEER/AliQACheckerBase.h
index 74686ea0a65..a2df5f06f20 100644
--- a/STEER/AliQACheckerBase.h
+++ b/STEER/AliQACheckerBase.h
@@ -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 @@ class AliQACheckerBase: public TNamed {
   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
diff --git a/STEER/AliQADataMaker.cxx b/STEER/AliQADataMaker.cxx
index 97e145b62b8..41a6a56ae79 100644
--- a/STEER/AliQADataMaker.cxx
+++ b/STEER/AliQADataMaker.cxx
@@ -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() ; 
 }
 
 //____________________________________________________________________________ 
diff --git a/STEER/AliQADataMaker.h b/STEER/AliQADataMaker.h
index 57a6336ce9f..1c25652f6a2 100644
--- a/STEER/AliQADataMaker.h
+++ b/STEER/AliQADataMaker.h
@@ -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 @@ class AliQADataMaker: public TNamed {
 	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 @@ class AliQADataMaker: public TNamed {
 	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 @@ class AliQADataMaker: public TNamed {
 
 	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 ; 
diff --git a/STEER/AliQADataMakerRec.cxx b/STEER/AliQADataMakerRec.cxx
index 8b7007460d8..f6d0522d6d0 100644
--- a/STEER/AliQADataMakerRec.cxx
+++ b/STEER/AliQADataMakerRec.cxx
@@ -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() ; 
 }
diff --git a/STEER/AliQADataMakerRec.h b/STEER/AliQADataMakerRec.h
index de2cffad211..0af5701eaa0 100644
--- a/STEER/AliQADataMakerRec.h
+++ b/STEER/AliQADataMakerRec.h
@@ -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 @@ class AliQADataMakerRec: public AliQADataMaker {
 	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; }
 
diff --git a/STEER/AliQADataMakerSim.cxx b/STEER/AliQADataMakerSim.cxx
index 45b516e0689..2dd293f654e 100644
--- a/STEER/AliQADataMakerSim.cxx
+++ b/STEER/AliQADataMakerSim.cxx
@@ -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() ; 
 }
diff --git a/STEER/AliQADataMakerSim.h b/STEER/AliQADataMakerSim.h
index 99bc0be53fb..143688e1760 100644
--- a/STEER/AliQADataMakerSim.h
+++ b/STEER/AliQADataMakerSim.h
@@ -34,20 +34,20 @@ class AliQADataMakerSim: public AliQADataMaker {
 	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: 
 	
diff --git a/STEER/AliQAManager.cxx b/STEER/AliQAManager.cxx
index 6aca2186966..8d7ea4afd7b 100644
--- a/STEER/AliQAManager.cxx
+++ b/STEER/AliQAManager.cxx
@@ -19,12 +19,12 @@
 // 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 ;
   }
 }  
diff --git a/STEER/AliQAManager.h b/STEER/AliQAManager.h
index d7b20ade3c8..911dbbc8f6d 100644
--- a/STEER/AliQAManager.h
+++ b/STEER/AliQAManager.h
@@ -10,17 +10,17 @@
 // 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 @@ class AliQAManager : public AliCDBManager {
 	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 @@ class AliQAManager : public AliCDBManager {
   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 @@ class AliQAManager : public AliCDBManager {
 	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 @@ class AliQAManager : public AliCDBManager {
 	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 @@ class AliQAManager : public AliCDBManager {
 	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
index 00000000000..6118e53b8b7
--- /dev/null
+++ b/STEER/AliQAv1.cxx
@@ -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 fgQADataFile ; 
+}
+
+//_______________________________________________________________
+TFile * AliQAv1::GetQAResultFile() 
+{
+  // opens the file to store the  Quality Assurance Data Checker results
+	if (fgQAResultFile) 
+		fgQAResultFile->Close() ; 
+	fgQAResultFile = 0x0 ; 
+//	if (!fgQAResultFile) { 
+		TString dirName(fgQAResultDirName) ; 
+		if ( dirName.Contains(fgkLabLocalFile)) 
+			dirName.ReplaceAll(fgkLabLocalFile, "") ;
+		TString fileName(dirName + fgQAResultFileName) ; 
+		TString opt("") ; 
+		if ( !gSystem->AccessPathName(fileName) )
+			opt = "UPDATE" ; 
+		else { 
+			if ( gSystem->AccessPathName(dirName) )
+				gSystem->mkdir(dirName) ; 
+			opt = "NEW" ; 
+		}
+		fgQAResultFile = TFile::Open(fileName, opt) ;   
+//	}
+	
+	return fgQAResultFile ;
+}
+
+//_______________________________________________________________
+AliQAv1::TASKINDEX_t AliQAv1::GetTaskIndex(const char * name) 
+{
+	// returns the detector index corresponding to a given name
+	TString sname(name) ; 
+	TASKINDEX_t rv = kNULLTASKINDEX ; 
+	for (Int_t tsk = 0; tsk < kNTASKINDEX ; tsk++) {
+		if ( GetTaskName(tsk) == sname ) {
+			rv = TASKINDEX_t(tsk) ; 
+			break ; 
+		}
+	}
+	return rv ; 		
+}
+
+//_______________________________________________________________
+Bool_t AliQAv1::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 AliQAv1::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, 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) ;
+  offset+= bit ;
+  status = (status & 1 << offset) != 0 ;
+  return status ;
+}
+
+//_______________________________________________________________
+Bool_t AliQAv1::IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) 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 ; 
+	for ( Int_t bit = 0 ; bit < kNBIT ; bit++) {
+		offset+= bit ;
+		st += (status & 1 << offset) != 0 ;		
+	}
+	if ( st == 0 ) 
+		return kFALSE ; 
+	else 
+		return kTRUE ;
+}
+//_______________________________________________________________
+Bool_t AliQAv1::IsSetAny(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es) const
+{
+  // Checks is the requested bit is set
+	
+  CheckRange(det) ; 
+  CheckRange(es) ; 
+	
+	ULong_t status = GetStatus(det, es) ;
+	ULong_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++) {
+			offset+= bit ;
+			st += (status & 1 << offset) != 0 ;		
+		}
+	}
+	if ( st == 0 ) 
+		return kFALSE ; 
+	else 
+		return kTRUE ;
+}
+
+//_______________________________________________________________
+AliQAv1 * AliQAv1::Instance()
+{
+  // Get an instance of the singleton. The only authorized way to call the ctor
+
+  if ( ! fgQA) {
+    TFile * f = GetQAResultFile() ; 
+    fgQA = dynamic_cast<AliQAv1 *>(f->Get("QA")) ; 
+    if ( ! fgQA ) 
+      fgQA = new AliQAv1() ;
+  }	
+  return fgQA ;
+}
+
+//_______________________________________________________________
+AliQAv1 * AliQAv1::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 AliQAv1(qalength, qa, eslength, es) ;
+  return fgQA ;
+}
+
+//_______________________________________________________________
+AliQAv1 * AliQAv1::Instance(const DETECTORINDEX_t det)
+{
+  // Get an instance of the singleton. The only authorized way to call the ctor
+  
+  if ( ! fgQA) {
+    TFile * f = GetQAResultFile() ; 
+	fgQA = dynamic_cast<AliQAv1 *>(f->Get("QA")) ; 
+    if ( ! fgQA ) 
+		fgQA = new AliQAv1(det) ;
+  }		
+  fgQA->Set(det) ;
+  return fgQA ;
+}
+
+//_______________________________________________________________
+AliQAv1 * AliQAv1::Instance(const ALITASK_t tsk)
+{
+  // Get an instance of the singleton. The only authorized way to call the ctor
+
+  if ( ! fgQA)
+    switch (tsk) {
+    case kNULLTASK:
+      break ;
+	case kRAW:
+      fgQA = new AliQAv1(tsk) ;
+      break ;
+	case kSIM:
+      fgQA = new AliQAv1(tsk) ;
+      break ;
+    case kREC:
+      printf("fgQA = gAlice->GetQA()") ;
+      break ;
+    case kESD:
+      printf("fgQA = dynamic_cast<AliQAv1 *> (esdFile->Get(\"QA\")") ;
+      break ;
+    case kANA:
+      printf("fgQA = dynamic_cast<AliQAv1 *> (esdFile->Get(\"QA\")") ;
+      break ;
+    case kNTASK:
+      break ;
+    }
+  if (fgQA) 
+    fgQA->Set(tsk) ;
+  return fgQA ;
+}
+
+//_______________________________________________________________
+AliQAv1 *  AliQAv1::Instance(const TASKINDEX_t tsk) 
+{
+	// get an instance of the singleton.
+	
+	ALITASK_t index = kNULLTASK ; 
+
+	if ( tsk == kRAWS )
+		index = kRAW ;
+	else if (tsk < kDIGITS)
+		index = kSIM ;
+	else if (tsk < kRECPARTICLES)
+		index = kREC ; 
+	else if (tsk == kESDS) 
+		index = kESD ; 
+
+	return Instance(index) ; 
+}
+
+//_______________________________________________________________
+void AliQAv1::Merge(TCollection * list) {
+	// Merge the QA resuls in the list into this single AliQAv1 object
+	
+	for (Int_t det = 0 ; det < kNDET ; det++) {
+		Set(DETECTORINDEX_t(det)) ; 
+		for (Int_t task = 0 ; task < kNTASK ; task++) {
+			Set(ALITASK_t(task)) ; 
+			for (Int_t bit = 0 ; bit < kNBIT ; bit++) {
+				TIter next(list) ;
+				AliQAv1 * qa ; 
+				while ( (qa = (AliQAv1*)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 list
+			} // bit
+		} // task
+	} // detector
+}
+
+//_______________________________________________________________
+ULong_t AliQAv1::Offset(ALITASK_t tsk) const
+{
+  // Calculates the bit offset for a given module (SIM, REC, ESD, ANA)
+
+  CheckRange(tsk) ; 
+
+  ULong_t offset = 0 ;
+  switch (tsk) {
+  case kNULLTASK:
+    break ;
+  case kRAW:
+    offset+= 0 ;
+    break ;
+  case kSIM:
+    offset+= 4 ;
+    break ;
+  case kREC:
+    offset+= 8 ;
+    break ;
+  case kESD:
+    offset+= 12 ;
+    break ;
+  case kANA:
+    offset+= 16 ;
+    break ;
+  case kNTASK:
+    break ;
+  }
+
+  return offset ;
+}
+
+//_______________________________________________________________
+void AliQAv1::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 AliQAv1::Set(QABIT_t bit, Int_t ies)
+{
+  // Set the status bit of the current detector in the current module and for the current event specie 
+   Set(bit, AliRecoParam::Convert(ies)) ;
+}
+
+//_______________________________________________________________
+void AliQAv1::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 
+  
+  SetStatusBit(fDet, fTask, es, bit) ;
+}
+
+//_____________________________________________________________________________
+void AliQAv1::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 ; 
+
+  else {
+	  printf("ERROR: %s is an invalid storage definition\n", name) ; 
+	  fgQARefDirName  = "" ; 
+	  fgQARefFileName = "" ; 
+  }	
+	TString tmp(fgQARefDirName) ; // + fgQARefFileName) ;
+	printf("AliQAv1::SetQARefDir: QA references are in  %s\n", tmp.Data() ) ;
+}
+
+//_____________________________________________________________________________
+void AliQAv1::SetQAResultDirName(const char * name)
+{
+  // Set the root directory where to store the QA status object
+
+  fgQAResultDirName.Prepend(name) ; 
+  printf("AliQAv1::SetQAResultDirName: QA results are in  %s\n", fgQAResultDirName.Data()) ;
+  if ( fgQAResultDirName.Contains(fgkLabLocalFile)) 
+    fgQAResultDirName.ReplaceAll(fgkLabLocalFile, "") ;
+  fgQAResultFileName.Prepend(fgQAResultDirName) ;
+}
+
+//_______________________________________________________________
+void AliQAv1::SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, 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) ;
+  offset+= bit ;
+  status = status | 1 << offset ;
+  SetStatus(det, es, status) ;
+}
+
+//_______________________________________________________________
+void AliQAv1::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 AliQAv1::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)) ;
+      }
+    }
+	}
+}
+
+//_______________________________________________________________
+void AliQAv1::ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) const
+{
+	// Prints the full QA status of a given detector
+	CheckRange(det) ;
+	CheckRange(es) ;
+	ULong_t status = GetStatus(det, es) ;
+	ULong_t tskStatus[kNTASK] ; 
+	tskStatus[kRAW] = status & 0x0000f ;
+	tskStatus[kSIM] = status & 0x000f0 ;
+	tskStatus[kREC] = status & 0x00f00 ;
+	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), 
+				 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]) ; 
+		} 
+	} else {
+			ShowASCIIStatus(es, det, tsk, tskStatus[tsk]) ; 
+	}
+}
+
+//_______________________________________________________________
+void AliQAv1::ShowASCIIStatus(AliRecoParam::EventSpecie_t es, 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))) {
+			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()) ; 
+}
+
+//_______________________________________________________________
+void AliQAv1::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 AliQAv1::UnSet(QABIT_t bit, AliRecoParam::EventSpecie_t es)
+{
+	// UnSet the status bit of the current detector in the current module
+	
+	UnSetStatusBit(fDet, fTask, es, bit) ;
+}
+
+//_______________________________________________________________
+void AliQAv1::UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, 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) ;
+	offset+= bit ;
+	status = status & 0 << offset ;
+	SetStatus(det, es, status) ;
+}
diff --git a/STEER/AliQAv1.h b/STEER/AliQAv1.h
new file mode 100644
index 00000000000..1404407a9fe
--- /dev/null
+++ b/STEER/AliQAv1.h
@@ -0,0 +1,153 @@
+#ifndef ALIQAv1_H
+#define ALIQAv1_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id: AliQAv1.h 31503 2009-03-16 11:01:16Z schutz $ */
+
+//
+// Quality Assurance Object
+//
+
+#include <TNamed.h> 
+#include <TMath.h> 
+class TFile ; 
+
+#include "AliLog.h"
+#include "AliRecoParam.h"
+
+class AliQAv1 : public TNamed {
+public:
+  
+  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 {
+    kNULLTASK=-1, kRAW, kSIM, kREC, kESD, kANA, kNTASK };
+  enum QABIT_t {
+    kNULLBit=-1, kINFO, kWARNING, kERROR, kFATAL, kNBIT };
+  enum TASKINDEX_t {
+    kNULLTASKINDEX=-1, kRAWS, kHITS, kSDIGITS, kDIGITS, kRECPOINTS, kTRACKSEGMENTS, kRECPARTICLES, kESDS, kNTASKINDEX };
+  
+  // Creators - destructors
+  AliQAv1(); // beware singleton, not to be used
+  AliQAv1(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es) ;
+  AliQAv1(const ALITASK_t tsk) ;
+  AliQAv1(const DETECTORINDEX_t det) ;
+  AliQAv1(const AliQAv1& qa) ;   
+  AliQAv1& operator = (const AliQAv1& qa) ;
+  virtual ~AliQAv1();
+  
+  static  AliQAv1 *        Instance() ;
+  static  AliQAv1 *        Instance(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es) ;
+  static  AliQAv1 *        Instance(const DETECTORINDEX_t det) ;
+  static  AliQAv1 *        Instance(const ALITASK_t tsk) ;
+  static  AliQAv1 *        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) ;
+  
+private:      
+  
+  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 AliQAv1 *       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(AliQAv1,2)  //ALICE Quality Assurance Object
+};
+#endif
diff --git a/STEER/AliReconstruction.cxx b/STEER/AliReconstruction.cxx
index 1285ae2fd90..e2691bdd9d2 100644
--- a/STEER/AliReconstruction.cxx
+++ b/STEER/AliReconstruction.cxx
@@ -162,7 +162,7 @@
 #include "AliMultiplicity.h"
 #include "AliPID.h"
 #include "AliPlaneEff.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQADataMakerRec.h" 
 #include "AliQAManager.h"
 #include "AliRawEvent.h"
@@ -279,7 +279,7 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename) :
     fLoader[iDet] = NULL;
     fTracker[iDet] = NULL;
   }
-  for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+  for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
     fQACycles[iDet] = 999999 ;
     fQAWriteExpert[iDet] = kFALSE ; 
   }
@@ -378,7 +378,7 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
     fTracker[iDet] = NULL;
   }  
   
-  for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+  for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
     fQACycles[iDet] = rec.fQACycles[iDet];
     fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ; 
   }
@@ -455,7 +455,7 @@ AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
     delete fTracker[iDet]; fTracker[iDet] = NULL;
   }
   
-  for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+  for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
     fQACycles[iDet] = rec.fQACycles[iDet];
     fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
   } 
@@ -558,28 +558,28 @@ void AliReconstruction::InitQA()
   
   if (fRunQA) {
   fQAManager->SetActiveDetectors(fQADetectors) ; 
-  for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
-    fQAManager->SetCycleLength(AliQA::DETECTORINDEX_t(det), fQACycles[det]) ;  
-    fQAManager->SetWriteExpert(AliQA::DETECTORINDEX_t(det)) ;
+  for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) {
+    fQAManager->SetCycleLength(AliQAv1::DETECTORINDEX_t(det), fQACycles[det]) ;  
+    fQAManager->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
   }
-  if (!fRawReader && fQATasks.Contains(AliQA::kRAWS))
-    fQATasks.ReplaceAll(Form("%d",AliQA::kRAWS), "") ;
+  if (!fRawReader && fQATasks.Contains(AliQAv1::kRAWS))
+    fQATasks.ReplaceAll(Form("%d",AliQAv1::kRAWS), "") ;
   fQAManager->SetTasks(fQATasks) ; 
   fQAManager->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ; 
   }
   if (fRunGlobalQA) {
     Bool_t sameCycle = kFALSE ;
-    AliQADataMaker *qadm = fQAManager->GetQADataMaker(AliQA::kGLOBAL);
+    AliQADataMaker *qadm = fQAManager->GetQADataMaker(AliQAv1::kGLOBAL);
     AliInfo(Form("Initializing the global QA data maker"));
-    if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
-      qadm->StartOfCycle(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ; 
-      TObjArray **arr=qadm->Init(AliQA::kRECPOINTS);
+    if (fQATasks.Contains(Form("%d", AliQAv1::kRECPOINTS))) {
+      qadm->StartOfCycle(AliQAv1::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ; 
+      TObjArray **arr=qadm->Init(AliQAv1::kRECPOINTS);
       AliTracker::SetResidualsArray(arr);
       sameCycle = kTRUE ; 
     }
-    if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
-      qadm->StartOfCycle(AliQA::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ; 
-      qadm->Init(AliQA::kESDS);
+    if (fQATasks.Contains(Form("%d", AliQAv1::kESDS))) {
+      qadm->StartOfCycle(AliQAv1::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ; 
+      qadm->Init(AliQAv1::kESDS);
     }
   }
     AliSysInfo::AddStamp("InitQA") ; 
@@ -662,7 +662,7 @@ void AliReconstruction::SetQARefDefaultStorage(const char* uri) {
   // Activate it later within the Run() method
   
   fQARefUri = uri;
-  AliQA::SetQARefStorage(fQARefUri.Data()) ;
+  AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
   
 }
 //_____________________________________________________________________________
@@ -1814,10 +1814,10 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
     fQAManager->RunOneEvent(fesd) ; 
   }
   if (fRunGlobalQA) {
-      AliQADataMaker *qadm = fQAManager->GetQADataMaker(AliQA::kGLOBAL);
+      AliQADataMaker *qadm = fQAManager->GetQADataMaker(AliQAv1::kGLOBAL);
       qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
-    if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS)))
-      qadm->Exec(AliQA::kESDS, fesd);
+    if (qadm && fQATasks.Contains(Form("%d", AliQAv1::kESDS)))
+      qadm->Exec(AliQAv1::kESDS, fesd);
   }
 
     if (fWriteESDfriend) {
@@ -1925,12 +1925,12 @@ void AliReconstruction::SlaveTerminate()
     fQAManager->EndOfCycle() ;
   
   if (fRunGlobalQA) {
-    AliQADataMaker *qadm = fQAManager->GetQADataMaker(AliQA::kGLOBAL);
+    AliQADataMaker *qadm = fQAManager->GetQADataMaker(AliQAv1::kGLOBAL);
     if (qadm) {
-      if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) 
-        qadm->EndOfCycle(AliQA::kRECPOINTS);
-      if (fQATasks.Contains(Form("%d", AliQA::kESDS))) 
-        qadm->EndOfCycle(AliQA::kESDS);
+      if (fQATasks.Contains(Form("%d", AliQAv1::kRECPOINTS))) 
+        qadm->EndOfCycle(AliQAv1::kRECPOINTS);
+      if (fQATasks.Contains(Form("%d", AliQAv1::kESDS))) 
+        qadm->EndOfCycle(AliQAv1::kESDS);
       qadm->Finish();
     }
   }
@@ -1946,7 +1946,7 @@ void AliReconstruction::Terminate()
   AliCodeTimerAuto("");
 
   AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
-  esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQA::Instance()->GetQA(), AliQA::Instance()->GetEventSpecies(), AliQA::kNDET, AliRecoParam::kNSpecies);
+  esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
 
   // Cleanup of CDB manager: cache and active storages!
   AliCDBManager::Instance()->ClearCache();
@@ -2895,24 +2895,24 @@ void AliReconstruction::CheckQA()
 //	TString newRunTracking ;
 //	TString newFillESD ;
 //	 
-//	for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
-//		TString detName(AliQA::GetDetName(iDet)) ;
-//		AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ;       
-//      if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, specie, AliQA::kFATAL)) {
+//	for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
+//		TString detName(AliQAv1::GetDetName(iDet)) ;
+//		AliQAv1 * qa = AliQAv1::Instance(AliQAv1::DETECTORINDEX_t(iDet)) ;       
+//      if ( qa->IsSet(AliQAv1::DETECTORINDEX_t(iDet), AliQAv1::kSIM, specie, AliQAv1::kFATAL)) {
 //        AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS  and/or Digits was Fatal; No reconstruction performed", 
 //                   detName.Data(), AliRecoParam::GetEventSpecieName(es))) ;
 //			} else {
-//			if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) || 
+//			if ( fRunLocalReconstruction.Contains(AliQAv1::GetDetName(iDet)) || 
 //					fRunLocalReconstruction.Contains("ALL") )  {
 //				newRunLocalReconstruction += detName ; 
 //				newRunLocalReconstruction += " " ; 			
 //			}
-//			if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) || 
+//			if ( fRunTracking.Contains(AliQAv1::GetDetName(iDet)) || 
 //					fRunTracking.Contains("ALL") )  {
 //				newRunTracking += detName ; 
 //				newRunTracking += " " ; 			
 //			}
-//			if ( fFillESD.Contains(AliQA::GetDetName(iDet)) || 
+//			if ( fFillESD.Contains(AliQAv1::GetDetName(iDet)) || 
 //					fFillESD.Contains("ALL") )  {
 //				newFillESD += detName ; 
 //				newFillESD += " " ; 			
@@ -3059,16 +3059,16 @@ Bool_t AliReconstruction::SetRunQA(TString detAndAction)
 		fQADetectors = fFillESD ; 
 		fQATasks   = detAndAction(colon+1, detAndAction.Sizeof() ) ; 
 	if (fQATasks.Contains("ALL") ) {
-		fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ; 
+		fQATasks = Form("%d %d %d", AliQAv1::kRAWS, AliQAv1::kRECPOINTS, AliQAv1::kESDS) ; 
 	} else {
 		fQATasks.ToUpper() ; 
 		TString tempo("") ; 
 		if ( fQATasks.Contains("RAW") ) 
-			tempo = Form("%d ", AliQA::kRAWS) ; 
+			tempo = Form("%d ", AliQAv1::kRAWS) ; 
 		if ( fQATasks.Contains("RECPOINT") ) 
-			tempo += Form("%d ", AliQA::kRECPOINTS) ; 
+			tempo += Form("%d ", AliQAv1::kRECPOINTS) ; 
 		if ( fQATasks.Contains("ESD") ) 
-			tempo += Form("%d ", AliQA::kESDS) ; 
+			tempo += Form("%d ", AliQAv1::kESDS) ; 
 		fQATasks = tempo ; 
 		if (fQATasks.IsNull()) {
 			AliInfo("No QA requested\n")  ;
@@ -3077,9 +3077,9 @@ Bool_t AliReconstruction::SetRunQA(TString detAndAction)
 		}
 	}	
 	TString tempo(fQATasks) ; 
-	tempo.ReplaceAll(Form("%d", AliQA::kRAWS), AliQA::GetTaskName(AliQA::kRAWS)) 	;
-	tempo.ReplaceAll(Form("%d", AliQA::kRECPOINTS), AliQA::GetTaskName(AliQA::kRECPOINTS)) ;	
-	tempo.ReplaceAll(Form("%d", AliQA::kESDS), AliQA::GetTaskName(AliQA::kESDS)) ; 	
+	tempo.ReplaceAll(Form("%d", AliQAv1::kRAWS), AliQAv1::GetTaskName(AliQAv1::kRAWS)) 	;
+	tempo.ReplaceAll(Form("%d", AliQAv1::kRECPOINTS), AliQAv1::GetTaskName(AliQAv1::kRECPOINTS)) ;	
+	tempo.ReplaceAll(Form("%d", AliQAv1::kESDS), AliQAv1::GetTaskName(AliQAv1::kESDS)) ; 	
 	AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;  
 	fRunQA = kTRUE ;
 	return kTRUE; 
diff --git a/STEER/AliReconstruction.h b/STEER/AliReconstruction.h
index e5302ec1499..d902b160fc6 100644
--- a/STEER/AliReconstruction.h
+++ b/STEER/AliReconstruction.h
@@ -41,7 +41,7 @@ class AliRecoParam;
 class AliDetectorRecoParam;
 class AliRunInfo;
 class AliGRPObject;
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliEventInfo.h"
 #include "AliRecoParam.h"
 
@@ -138,8 +138,8 @@ class AliReconstruction: public TSelector {
   void        ImportRunLoader(AliRunLoader* rl) { fRunLoader = rl; }
 
   // Quality Assurance 
-  void    SetQACycles(AliQA::DETECTORINDEX_t det, Int_t cycles) { fQACycles[det] = cycles ; }
-  void    SetQAWriteExpert(AliQA::DETECTORINDEX_t det) { fQAWriteExpert[det] = kTRUE ; }
+  void    SetQACycles(AliQAv1::DETECTORINDEX_t det, Int_t cycles) { fQACycles[det] = cycles ; }
+  void    SetQAWriteExpert(AliQAv1::DETECTORINDEX_t det) { fQAWriteExpert[det] = kTRUE ; }
   Bool_t  SetRunQA(TString detAndAction="ALL:ALL") ; 
   void    SetRunGlobalQA(Bool_t flag=kTRUE){fRunGlobalQA = flag;}
   void    SetQARefDefaultStorage(const char* uri);
@@ -268,8 +268,8 @@ class AliReconstruction: public TSelector {
   Bool_t 	 fSetRunNumberFromDataCalled;  //! flag to check if run number is already loaded from run loader
 
   //Quality Assurance
-  Int_t  fQACycles[     AliQA::kNDET];  // # events over which QA data are accumulated
-  Bool_t fQAWriteExpert[AliQA::kNDET];  // Flag to save or not expert QA data
+  Int_t  fQACycles[     AliQAv1::kNDET];  // # events over which QA data are accumulated
+  Bool_t fQAWriteExpert[AliQAv1::kNDET];  // Flag to save or not expert QA data
   TString               fQADetectors ;  // list of detectors to be QA'ed 	
   AliQAManager * fQAManager    ;   //! steering class to run QA
   TString               fQATasks ;      // list of QA tasks to be performed	
diff --git a/STEER/AliSimulation.cxx b/STEER/AliSimulation.cxx
index 06a0d6a8f18..48ac524816a 100644
--- a/STEER/AliSimulation.cxx
+++ b/STEER/AliSimulation.cxx
@@ -206,7 +206,7 @@ AliSimulation::AliSimulation(const char* configFileName,
 // for QA
 	fQAManager = AliQAManager::QAManager("sim") ; 
 	fQAManager->SetActiveDetectors(fQADetectors) ; 
-	fQATasks = Form("%d %d %d", AliQA::kHITS, AliQA::kSDIGITS, AliQA::kDIGITS) ; 
+	fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ; 
 	fQAManager->SetTasks(fQATasks) ; 	
 }
 
@@ -253,7 +253,7 @@ void AliSimulation::InitQA()
 
   fQAManager = AliQAManager::QAManager("sim") ; 
   fQAManager->SetActiveDetectors(fQADetectors) ; 
-  fQATasks = Form("%d %d %d", AliQA::kHITS, AliQA::kSDIGITS, AliQA::kDIGITS) ; 
+  fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ; 
   fQAManager->SetTasks(fQATasks) ;
  	if (fWriteQAExpertData)
     fQAManager->SetWriteExpert() ; 
@@ -383,7 +383,7 @@ void AliSimulation::SetQARefDefaultStorage(const char* uri) {
   // Activate it later within the Run() method
   
   fQARefUri = uri;
-  AliQA::SetQARefStorage(fQARefUri.Data()) ;
+  AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
 }
 
 //_____________________________________________________________________________
@@ -2064,16 +2064,16 @@ Bool_t AliSimulation::SetRunQA(TString detAndAction)
 		fQADetectors = Form("%s %s", fMakeDigits.Data(), fMakeDigitsFromHits.Data()) ; 
 		fQATasks   = detAndAction(colon+1, detAndAction.Sizeof() ) ; 
 	if (fQATasks.Contains("ALL") ) {
-		fQATasks = Form("%d %d %d", AliQA::kHITS, AliQA::kSDIGITS, AliQA::kDIGITS) ; 
+		fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ; 
 	} else {
 		fQATasks.ToUpper() ; 
 		TString tempo("") ; 
 		if ( fQATasks.Contains("HIT") ) 
-			tempo = Form("%d ", AliQA::kHITS) ; 
+			tempo = Form("%d ", AliQAv1::kHITS) ; 
 		if ( fQATasks.Contains("SDIGIT") ) 
-			tempo += Form("%d ", AliQA::kSDIGITS) ; 
+			tempo += Form("%d ", AliQAv1::kSDIGITS) ; 
 		if ( fQATasks.Contains("DIGIT") ) 
-			tempo += Form("%d ", AliQA::kDIGITS) ; 
+			tempo += Form("%d ", AliQAv1::kDIGITS) ; 
 		fQATasks = tempo ; 
 		if (fQATasks.IsNull()) {
 			AliInfo("No QA requested\n")  ;
@@ -2082,15 +2082,15 @@ Bool_t AliSimulation::SetRunQA(TString detAndAction)
 		}
 	}	
 	TString tempo(fQATasks) ; 
-    tempo.ReplaceAll(Form("%d", AliQA::kHITS), AliQA::GetTaskName(AliQA::kHITS)) 	;
-    tempo.ReplaceAll(Form("%d", AliQA::kSDIGITS), AliQA::GetTaskName(AliQA::kSDIGITS)) ;	
-    tempo.ReplaceAll(Form("%d", AliQA::kDIGITS), AliQA::GetTaskName(AliQA::kDIGITS)) ; 	
+    tempo.ReplaceAll(Form("%d", AliQAv1::kHITS), AliQAv1::GetTaskName(AliQAv1::kHITS)) 	;
+    tempo.ReplaceAll(Form("%d", AliQAv1::kSDIGITS), AliQAv1::GetTaskName(AliQAv1::kSDIGITS)) ;	
+    tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITS), AliQAv1::GetTaskName(AliQAv1::kDIGITS)) ; 	
 	AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;  
 	fRunQA = kTRUE ;
 	fQAManager->SetActiveDetectors(fQADetectors) ; 
 	fQAManager->SetTasks(fQATasks) ; 
-  for (Int_t det = 0 ; det < AliQA::kNDET ; det++) 
-    fQAManager->SetWriteExpert(AliQA::DETECTORINDEX_t(det)) ;
+  for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) 
+    fQAManager->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
   
 	return kTRUE; 
 } 
diff --git a/STEER/AliSimulation.h b/STEER/AliSimulation.h
index 1667b089067..afd915645ff 100644
--- a/STEER/AliSimulation.h
+++ b/STEER/AliSimulation.h
@@ -15,7 +15,7 @@
 #include <TNamed.h>
 #include <TString.h>
 #include <TObjArray.h>
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAManager.h"
 
 class AliCDBId;
@@ -112,10 +112,10 @@ class AliSimulation: public TNamed {
 
   //Quality Assurance
   Int_t       GetDetIndex(const char * detector);
-  void        SetQACycles(AliQA::DETECTORINDEX_t det, const Int_t cycles) {  fQAManager->SetCycleLength(det, cycles) ; }
+  void        SetQACycles(AliQAv1::DETECTORINDEX_t det, const Int_t cycles) {  fQAManager->SetCycleLength(det, cycles) ; }
   Bool_t      RunQA() ;
   Bool_t      SetRunQA(TString detAndAction="ALL:ALL") ; 
-  void        SetQAWriteExpert(AliQA::DETECTORINDEX_t det) { fQAManager->SetWriteExpert(det) ; }  
+  void        SetQAWriteExpert(AliQAv1::DETECTORINDEX_t det) { fQAManager->SetWriteExpert(det) ; }  
   void        SetQARefDefaultStorage(const char* uri);
   void        InitQA();
   void        SetEventSpecie(AliRecoParam::EventSpecie_t es) { fEventSpecie = es ; }
diff --git a/STEER/CMake_libSTEER.txt b/STEER/CMake_libSTEER.txt
index 54d66be197c..2752d59a8b8 100644
--- a/STEER/CMake_libSTEER.txt
+++ b/STEER/CMake_libSTEER.txt
@@ -66,7 +66,7 @@ AliGRPRecoParam.cxx
 AliRelAlignerKalman.cxx 
 AliESDTagCreator.cxx 
 AliGRPObject.cxx
-AliQA.cxx
+AliQAv1.cxx
 AliRunInfo.cxx AliEventInfo.cxx 
 AliRecoParam.cxx 
 AliDetectorRecoParam.cxx 
diff --git a/STEER/CMake_libSTEERBase.txt b/STEER/CMake_libSTEERBase.txt
index 230fb15d178..8db8874bdb8 100644
--- a/STEER/CMake_libSTEERBase.txt
+++ b/STEER/CMake_libSTEERBase.txt
@@ -27,6 +27,7 @@ set(SRCS
   AliPDG.cxx
   AliTimeStamp.cxx AliTriggerScalers.cxx AliTriggerScalersRecord.cxx
   AliExternalTrackParam.cxx
+  AliQA.cxx
 )
 
 # fill list of header files from list of source files
diff --git a/STEER/STEERBaseLinkDef.h b/STEER/STEERBaseLinkDef.h
index 0316460410d..b9c440711b7 100644
--- a/STEER/STEERBaseLinkDef.h
+++ b/STEER/STEERBaseLinkDef.h
@@ -71,5 +71,6 @@
 #pragma link C++ class AliTriggerScalersRecord+;
 
 #pragma link C++ class  AliExternalTrackParam+;
+#pragma link C++ class AliQA+;
 
 #endif
diff --git a/STEER/STEERLinkDef.h b/STEER/STEERLinkDef.h
index 4621ca3116b..1c3f28884ff 100644
--- a/STEER/STEERLinkDef.h
+++ b/STEER/STEERLinkDef.h
@@ -142,7 +142,7 @@
 
 #pragma link C++ class AliGRPObject+;
 
-#pragma link C++ class AliQA+;
+#pragma link C++ class AliQAv1+;
 
 #pragma link C++ class AliRunInfo+;
 #pragma link C++ class AliEventInfo+;
diff --git a/STEER/libSTEER.pkg b/STEER/libSTEER.pkg
index f54f4818ba2..9be912912c1 100644
--- a/STEER/libSTEER.pkg
+++ b/STEER/libSTEER.pkg
@@ -65,7 +65,7 @@ AliGRPRecoParam.cxx \
 AliRelAlignerKalman.cxx \
 AliESDTagCreator.cxx \
 AliGRPObject.cxx \
-AliQA.cxx \
+AliQAv1.cxx \
 AliRunInfo.cxx AliEventInfo.cxx \
 AliRecoParam.cxx AliDetectorRecoParam.cxx \
 AliMillePede2.cxx AliMatrixSq.cxx AliMatrixSparse.cxx AliSymMatrix.cxx AliMinResSolve.cxx
diff --git a/STEER/libSTEERBase.pkg b/STEER/libSTEERBase.pkg
index 1518668cbeb..a490e20bd35 100644
--- a/STEER/libSTEERBase.pkg
+++ b/STEER/libSTEERBase.pkg
@@ -25,7 +25,7 @@ SRCS = AliVParticle.cxx \
        AliCodeTimer.cxx \
        AliPDG.cxx \
        AliTimeStamp.cxx AliTriggerScalers.cxx AliTriggerScalersRecord.cxx \
-       AliExternalTrackParam.cxx
+       AliExternalTrackParam.cxx AliQA.cxx
 
 
 HDRS:= $(SRCS:.cxx=.h) 
diff --git a/T0/AliT0QAChecker.cxx b/T0/AliT0QAChecker.cxx
index fe38f5fcdca..bd9c44866bb 100644
--- a/T0/AliT0QAChecker.cxx
+++ b/T0/AliT0QAChecker.cxx
@@ -44,7 +44,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliT0QAChecker.h"
 
@@ -52,7 +52,7 @@ ClassImp(AliT0QAChecker)
 
 
 //____________________________________________________________________________
-Double_t * AliT0QAChecker::Check(AliQA::ALITASK_t /*index*/)
+Double_t * AliT0QAChecker::Check(AliQAv1::ALITASK_t /*index*/)
 {
   Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ; 
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
@@ -61,7 +61,7 @@ Double_t * AliT0QAChecker::Check(AliQA::ALITASK_t /*index*/)
 }
 
 //__________________________________________________________________
-Double_t * AliT0QAChecker::Check(AliQA::ALITASK_t index,TObjArray ** list)
+Double_t * AliT0QAChecker::Check(AliQAv1::ALITASK_t index,TObjArray ** list)
 {
 
   // Super-basic check on the QA histograms on the input list:
@@ -82,7 +82,7 @@ Double_t * AliT0QAChecker::Check(AliQA::ALITASK_t index,TObjArray ** list)
   TH1 *fhESD[2];
   
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
-    //  TString dataType = AliQA::GetAliTaskName(index);
+    //  TString dataType = AliQAv1::GetAliTaskName(index);
     if (list[specie]->GetEntries() == 0){
       test[specie] = 1. ; // nothing to check
     }
diff --git a/T0/AliT0QAChecker.h b/T0/AliT0QAChecker.h
index 1588b8b9cbb..df75ed72d9c 100644
--- a/T0/AliT0QAChecker.h
+++ b/T0/AliT0QAChecker.h
@@ -30,8 +30,8 @@ class AliT0QAChecker: public AliQACheckerBase {
  // dtor
  virtual ~AliT0QAChecker() {;}
 private:
-  virtual Double_t * Check(AliQA::ALITASK_t) ; 
-  virtual Double_t * Check(AliQA::ALITASK_t, TObjArray ** list) ;
+  virtual Double_t * Check(AliQAv1::ALITASK_t) ; 
+  virtual Double_t * Check(AliQAv1::ALITASK_t, TObjArray ** list) ;
   
   ClassDef(AliT0QAChecker,1)  // description 
 
diff --git a/T0/AliT0QADataMaker.cxx b/T0/AliT0QADataMaker.cxx
index 4cc90e976d1..98c927e6f1b 100644
--- a/T0/AliT0QADataMaker.cxx
+++ b/T0/AliT0QADataMaker.cxx
@@ -44,7 +44,7 @@ ClassImp(AliT0QADataMaker)
            
 //____________________________________________________________________________ 
   AliT0QADataMaker::AliT0QADataMaker() : 
-  AliQADataMaker(AliQA::GetDetName(AliQA::kT0), "T0 Quality Assurance Data Maker")
+  AliQADataMaker(AliQAv1::GetDetName(AliQAv1::kT0), "T0 Quality Assurance Data Maker")
 
 {
   // ctor
@@ -91,11 +91,11 @@ AliT0QADataMaker& AliT0QADataMaker::operator = (const AliT0QADataMaker& qadm )
   return *this;
 }
 //____________________________________________________________________________
-void AliT0QADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list)
+void AliT0QADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX task, TObjArray * list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kT0, task, list) ;
+  AliQAChecker::Instance()->Run(AliQAv1::kT0, task, list) ;
 }
 
 //____________________________________________________________________________
diff --git a/T0/AliT0QADataMaker.h b/T0/AliT0QADataMaker.h
index fbc4d7d1181..6954517de73 100644
--- a/T0/AliT0QADataMaker.h
+++ b/T0/AliT0QADataMaker.h
@@ -40,7 +40,7 @@ class AliT0QADataMaker: public AliQADataMaker {
   virtual void   MakeDigits(TTree* digitsTree) ;   //Fill Digit QA histo
   virtual void   MakeRecPoints(TTree * clusters)    ;  //Fill cluster QA histo
   virtual void   MakeESDs(AliESDEvent * esd) ;         //Fill hit QA histo
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX, TObjArray * list) ;
   virtual void   StartOfDetectorCycle() ;
   ClassDef(AliT0QADataMaker,1)  // description 
 
diff --git a/T0/AliT0QADataMakerRec.cxx b/T0/AliT0QADataMakerRec.cxx
index 9fd3bedda68..3da4b089679 100644
--- a/T0/AliT0QADataMakerRec.cxx
+++ b/T0/AliT0QADataMakerRec.cxx
@@ -44,7 +44,7 @@ ClassImp(AliT0QADataMakerRec)
            
 //____________________________________________________________________________ 
   AliT0QADataMakerRec::AliT0QADataMakerRec() : 
-AliQADataMakerRec(AliQA::GetDetName(AliQA::kT0), 
+AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kT0), 
 		  "T0 Quality Assurance Data Maker"),
   fnEvent(0)
 
@@ -81,14 +81,14 @@ AliT0QADataMakerRec& AliT0QADataMakerRec::operator = (const AliT0QADataMakerRec&
   return *this;
 }
 //____________________________________________________________________________
-void AliT0QADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliT0QADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kT0, task, list) ;
+  AliQAChecker::Instance()->Run(AliQAv1::kT0, task, list) ;
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
     SetEventSpecie(specie) ; 
-    if ( task == AliQA::kRAWS ) {
+    if ( task == AliQAv1::kRAWS ) {
       const Char_t *triggers[6] = {"mean", "vertex","ORA","ORC","central","semi-central"};
       for (Int_t itr=0; itr<6; itr++) {
         GetRawsData(197)->Fill(triggers[itr], fNumTriggersCal[itr]);
@@ -104,7 +104,7 @@ void AliT0QADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray
       GetRawsData(207)->GetXaxis()->SetTitle("#PMT");
       GetRawsData(207)->GetYaxis()->SetTitle("Charge, #channels");
     }
-    if ( task == AliQA::kRECPOINTS) {
+    if ( task == AliQAv1::kRECPOINTS) {
       GetRecPointsData(0)->SetOption("COLZ");
       GetRecPointsData(1)->SetOption("COLZ");
       GetRecPointsData(0)->GetXaxis()->SetTitle("#PMT");
diff --git a/T0/AliT0QADataMakerRec.h b/T0/AliT0QADataMakerRec.h
index 9a72b2cf181..32b735da839 100644
--- a/T0/AliT0QADataMakerRec.h
+++ b/T0/AliT0QADataMakerRec.h
@@ -37,7 +37,7 @@ class AliT0QADataMakerRec: public AliQADataMakerRec {
   virtual void   MakeRaws(AliRawReader* rawReader) ;
   virtual void   MakeRecPoints(TTree * clusters)    ;  //Fill cluster QA histo
   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() ;
 
   Int_t fNumTriggers[6];  //number of trigger signals;
diff --git a/T0/AliT0QADataMakerSim.cxx b/T0/AliT0QADataMakerSim.cxx
index 5f51c6e5ae5..c5bff399fed 100644
--- a/T0/AliT0QADataMakerSim.cxx
+++ b/T0/AliT0QADataMakerSim.cxx
@@ -44,7 +44,7 @@ ClassImp(AliT0QADataMakerSim)
            
 //____________________________________________________________________________ 
   AliT0QADataMakerSim::AliT0QADataMakerSim() : 
-  AliQADataMakerSim(AliQA::GetDetName(AliQA::kT0), "T0 Quality Assurance Data Maker")
+  AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kT0), "T0 Quality Assurance Data Maker")
 
 {
   // ctor
@@ -91,11 +91,11 @@ AliT0QADataMakerSim& AliT0QADataMakerSim::operator = (const AliT0QADataMakerSim&
   return *this;
 }
 //____________________________________________________________________________
-void AliT0QADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliT0QADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kT0, task, list) ;
+  AliQAChecker::Instance()->Run(AliQAv1::kT0, task, list) ;
 }
 
 //____________________________________________________________________________
diff --git a/T0/AliT0QADataMakerSim.h b/T0/AliT0QADataMakerSim.h
index a38fe8fece8..b1adf8092c7 100644
--- a/T0/AliT0QADataMakerSim.h
+++ b/T0/AliT0QADataMakerSim.h
@@ -37,7 +37,7 @@ class AliT0QADataMakerSim: public AliQADataMakerSim {
   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(AliT0QADataMakerSim,1)  // description 
 
diff --git a/TOF/AliTOFQAChecker.cxx b/TOF/AliTOFQAChecker.cxx
index 89a5cd87dcb..cf85d840489 100644
--- a/TOF/AliTOFQAChecker.cxx
+++ b/TOF/AliTOFQAChecker.cxx
@@ -28,7 +28,7 @@
 #include "TObjArray.h"
 
 #include "AliLog.h"
-//#include "AliQA.h"
+//#include "AliQAv1.h"
 //#include "AliQAChecker.h"
 
 #include "AliTOFQAChecker.h"
@@ -36,7 +36,7 @@
 ClassImp(AliTOFQAChecker)
 
 //____________________________________________________________________________
-Double_t * AliTOFQAChecker::Check(AliQA::ALITASK_t /*index*/, TObjArray ** list) 
+Double_t * AliTOFQAChecker::Check(AliQAv1::ALITASK_t /*index*/, TObjArray ** list) 
 {
 
   // Super-basic check on the QA histograms on the input list: 
@@ -47,7 +47,7 @@ Double_t * AliTOFQAChecker::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.0 ; // nothing to check
diff --git a/TOF/AliTOFQAChecker.h b/TOF/AliTOFQAChecker.h
index 397900fe876..d213cfa5f55 100644
--- a/TOF/AliTOFQAChecker.h
+++ b/TOF/AliTOFQAChecker.h
@@ -11,7 +11,7 @@
 //                                                                 // 
 /////////////////////////////////////////////////////////////////////
 
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQACheckerBase.h"
 
 //class TFile ; 
@@ -27,8 +27,8 @@ class AliTOFQAChecker: public AliQACheckerBase {
 
  protected:
 
-  virtual Double_t * Check(AliQA::ALITASK_t /*index*/, TObjArray ** list) ;
-  virtual Double_t * Check(AliQA::ALITASK_t /*index*/) {return NULL;} 
+  virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/, TObjArray ** list) ;
+  virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/) {return NULL;} 
   
   ClassDef(AliTOFQAChecker,2)  // description 
 
diff --git a/TOF/AliTOFQADataMaker.cxx b/TOF/AliTOFQADataMaker.cxx
index dd9f79c0684..3cce8c7b905 100644
--- a/TOF/AliTOFQADataMaker.cxx
+++ b/TOF/AliTOFQADataMaker.cxx
@@ -43,7 +43,7 @@ ClassImp(AliTOFQADataMaker)
            
 //____________________________________________________________________________ 
   AliTOFQADataMaker::AliTOFQADataMaker() : 
-  AliQADataMaker(AliQA::GetDetName(AliQA::kTOF), "TOF Quality Assurance Data Maker")
+  AliQADataMaker(AliQAv1::GetDetName(AliQAv1::kTOF), "TOF Quality Assurance Data Maker")
 {
   //
   // ctor
@@ -566,12 +566,12 @@ void AliTOFQADataMaker::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliTOFQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list)
+void AliTOFQADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX task, TObjArray * list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
 
-  AliQAChecker::Instance()->Run(AliQA::kTOF, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kTOF, task, list) ;  
 }
 //____________________________________________________________________________
 void AliTOFQADataMaker::GetMapIndeces(Int_t* in , Int_t* out)
diff --git a/TOF/AliTOFQADataMaker.h b/TOF/AliTOFQADataMaker.h
index 5b6dc7c1cb1..e43e5632f3c 100644
--- a/TOF/AliTOFQADataMaker.h
+++ b/TOF/AliTOFQADataMaker.h
@@ -38,7 +38,7 @@ class AliTOFQADataMaker: public AliQADataMaker {
   virtual void   MakeRecPoints(TTree * recTree) ; 
   virtual void   MakeRaws(AliRawReader* rawReader) ; 
   virtual void   StartOfDetectorCycle() ; 
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX, TObjArray * list) ;
   virtual void   GetMapIndeces(Int_t *in, Int_t *out) ; 
 
   ClassDef(AliTOFQADataMaker,1)  // description 
diff --git a/TOF/AliTOFQADataMakerRec.cxx b/TOF/AliTOFQADataMakerRec.cxx
index c6c7d79797d..cffb576e1a0 100644
--- a/TOF/AliTOFQADataMakerRec.cxx
+++ b/TOF/AliTOFQADataMakerRec.cxx
@@ -43,7 +43,7 @@ ClassImp(AliTOFQADataMakerRec)
            
 //____________________________________________________________________________ 
   AliTOFQADataMakerRec::AliTOFQADataMakerRec() : 
-  AliQADataMakerRec(AliQA::GetDetName(AliQA::kTOF), "TOF Quality Assurance Data Maker")
+  AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kTOF), "TOF Quality Assurance Data Maker")
 {
   //
   // ctor
@@ -313,12 +313,12 @@ void AliTOFQADataMakerRec::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliTOFQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliTOFQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
 
-  AliQAChecker::Instance()->Run(AliQA::kTOF, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kTOF, task, list) ;  
 }
 //____________________________________________________________________________
 void AliTOFQADataMakerRec::GetMapIndeces(Int_t* in , Int_t* out)
diff --git a/TOF/AliTOFQADataMakerRec.h b/TOF/AliTOFQADataMakerRec.h
index f883b1657ec..21f050ed3b7 100644
--- a/TOF/AliTOFQADataMakerRec.h
+++ b/TOF/AliTOFQADataMakerRec.h
@@ -29,7 +29,7 @@ class AliTOFQADataMakerRec: public AliQADataMakerRec {
   virtual void   MakeRecPoints(TTree * recTree) ; 
   virtual void   MakeRaws(AliRawReader* rawReader) ; 
   virtual void   StartOfDetectorCycle() ; 
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) ;
   virtual void   GetMapIndeces(Int_t *in, Int_t *out) ; 
 
   ClassDef(AliTOFQADataMakerRec,1)  // description 
diff --git a/TOF/AliTOFQADataMakerSim.cxx b/TOF/AliTOFQADataMakerSim.cxx
index bd7896ad771..04b19cc908b 100644
--- a/TOF/AliTOFQADataMakerSim.cxx
+++ b/TOF/AliTOFQADataMakerSim.cxx
@@ -43,7 +43,7 @@ ClassImp(AliTOFQADataMakerSim)
            
 //____________________________________________________________________________ 
   AliTOFQADataMakerSim::AliTOFQADataMakerSim() : 
-  AliQADataMakerSim(AliQA::GetDetName(AliQA::kTOF), "TOF Quality Assurance Data Maker")
+  AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kTOF), "TOF Quality Assurance Data Maker")
 {
   //
   // ctor
@@ -338,12 +338,12 @@ void AliTOFQADataMakerSim::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliTOFQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliTOFQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
 
-  AliQAChecker::Instance()->Run(AliQA::kTOF, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kTOF, task, list) ;  
 }
 //____________________________________________________________________________
 void AliTOFQADataMakerSim::GetMapIndeces(Int_t* in , Int_t* out)
diff --git a/TOF/AliTOFQADataMakerSim.h b/TOF/AliTOFQADataMakerSim.h
index 98fbde5a7a3..ca83267093f 100644
--- a/TOF/AliTOFQADataMakerSim.h
+++ b/TOF/AliTOFQADataMakerSim.h
@@ -32,7 +32,7 @@ class AliTOFQADataMakerSim: public AliQADataMakerSim {
   virtual void   MakeSDigits(TClonesArray * sdigits) ; 
   virtual void   MakeSDigits(TTree * sdigTree);
   virtual void   StartOfDetectorCycle() ; 
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) ;
   virtual void   GetMapIndeces(Int_t *in, Int_t *out) ; 
 
   ClassDef(AliTOFQADataMakerSim,1)  // description 
diff --git a/TPC/AliTPCQADataMakerRec.cxx b/TPC/AliTPCQADataMakerRec.cxx
index e9337628381..8298ea45eb5 100644
--- a/TPC/AliTPCQADataMakerRec.cxx
+++ b/TPC/AliTPCQADataMakerRec.cxx
@@ -68,7 +68,7 @@ ClassImp(AliTPCQADataMakerRec)
 
 //____________________________________________________________________________ 
 AliTPCQADataMakerRec::AliTPCQADataMakerRec() : 
-  AliQADataMakerRec(AliQA::GetDetName(AliQA::kTPC), 
+  AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kTPC), 
 		    "TPC Rec Quality Assurance Data Maker"),
   fTPCdataQA(NULL)
 {
@@ -129,12 +129,12 @@ AliTPCQADataMakerRec::~AliTPCQADataMakerRec()
 }
  
 //____________________________________________________________________________ 
-void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
-    if ( !AliQA::Instance()->IsEventSpecieSet(specie) ) 
+    if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) 
       continue ; 
     if(fTPCdataQA[specie] != NULL) { // do the final step of the QA for Raw data
 
@@ -228,7 +228,7 @@ void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray
       }
     }
   }
-  AliQAChecker::Instance()->Run(AliQA::kTPC, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kTPC, task, list) ;  
 }
 
 //____________________________________________________________________________ 
diff --git a/TPC/AliTPCQADataMakerRec.h b/TPC/AliTPCQADataMakerRec.h
index e4cae64c422..5af6c625390 100644
--- a/TPC/AliTPCQADataMakerRec.h
+++ b/TPC/AliTPCQADataMakerRec.h
@@ -40,7 +40,7 @@ class AliTPCQADataMakerRec: public AliQADataMakerRec {
   
 private:
   virtual void   StartOfDetectorCycle() {}; // empty 
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray** list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray** list) ;
 
   // ESD QA
   virtual void   InitESDs() ; 
diff --git a/TPC/AliTPCQADataMakerSim.cxx b/TPC/AliTPCQADataMakerSim.cxx
index 6b8ff1aa073..b249a488716 100644
--- a/TPC/AliTPCQADataMakerSim.cxx
+++ b/TPC/AliTPCQADataMakerSim.cxx
@@ -48,7 +48,7 @@ ClassImp(AliTPCQADataMakerSim)
 
 //____________________________________________________________________________ 
 AliTPCQADataMakerSim::AliTPCQADataMakerSim() : 
-  AliQADataMakerSim(AliQA::GetDetName(AliQA::kTPC), 
+  AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kTPC), 
 		    "TPC Sim Quality Assurance Data Maker")
 {
   // ctor
@@ -78,11 +78,11 @@ AliTPCQADataMakerSim& AliTPCQADataMakerSim::operator = (const AliTPCQADataMakerS
 }
  
 //____________________________________________________________________________ 
-void AliTPCQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliTPCQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kTPC, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kTPC, task, list) ;  
 }
 
 //____________________________________________________________________________ 
diff --git a/TPC/AliTPCQADataMakerSim.h b/TPC/AliTPCQADataMakerSim.h
index 77b20fb6918..bce2afb67c0 100644
--- a/TPC/AliTPCQADataMakerSim.h
+++ b/TPC/AliTPCQADataMakerSim.h
@@ -39,7 +39,7 @@ class AliTPCQADataMakerSim: public AliQADataMakerSim {
   
 private:
   virtual void   StartOfDetectorCycle() {}; // empty 
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray** list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray** list) ;
 
   // Digits QA
   virtual void   InitDigits();
diff --git a/TRD/AliTRDQAChecker.cxx b/TRD/AliTRDQAChecker.cxx
index 2d3d3aaebad..caf703bbc5f 100644
--- a/TRD/AliTRDQAChecker.cxx
+++ b/TRD/AliTRDQAChecker.cxx
@@ -31,7 +31,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliTRDQAChecker.h"
 
diff --git a/TRD/AliTRDQAChecker.h b/TRD/AliTRDQAChecker.h
index 3572b3ff82a..d7fa324b1c1 100644
--- a/TRD/AliTRDQAChecker.h
+++ b/TRD/AliTRDQAChecker.h
@@ -22,7 +22,7 @@ class TObjArray;
 // --- Standard library ---
 
 // --- AliRoot header files ---
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQACheckerBase.h"
 class AliTRDLoader ; 
 
@@ -33,10 +33,10 @@ class AliTRDQAChecker: public AliQACheckerBase {
   AliTRDQAChecker(const AliTRDQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()) {;} // cpy ctor   
   virtual ~AliTRDQAChecker() {;} // dtor
 
-  virtual Double_t * Check(AliQA::ALITASK_t /*index*/) {return NULL;}
+  virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/) {return NULL;}
   virtual Double_t * Check(TList * /*list*/) {return NULL;}
-  virtual Double_t * Check(AliQA::ALITASK_t /*index*/, TObjArray ** /*list*/) {return NULL;}
-  virtual Double_t * Check(AliQA::ALITASK_t /*index*/, TNtupleD** /*nt*/)     {return NULL;}
+  virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/, TObjArray ** /*list*/) {return NULL;}
+  virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/, TNtupleD** /*nt*/)     {return NULL;}
 
 private:
   
diff --git a/TRD/AliTRDQADataMaker.cxx b/TRD/AliTRDQADataMaker.cxx
index 1f6524ee335..a395d33b4db 100644
--- a/TRD/AliTRDQADataMaker.cxx
+++ b/TRD/AliTRDQADataMaker.cxx
@@ -53,7 +53,7 @@ ClassImp(AliTRDQADataMaker)
 
 //____________________________________________________________________________ 
   AliTRDQADataMaker::AliTRDQADataMaker() : 
-  AliQADataMaker(AliQA::GetDetName(AliQA::kTRD), "TRD Quality Assurance Data Maker")
+  AliQADataMaker(AliQAv1::GetDetName(AliQAv1::kTRD), "TRD Quality Assurance Data Maker")
 {
   //
   // Default constructor
@@ -86,7 +86,7 @@ AliTRDQADataMaker& AliTRDQADataMaker::operator=(const AliTRDQADataMaker& qadm)
 }
 
 //____________________________________________________________________________ 
-void AliTRDQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list)
+void AliTRDQADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX task, TObjArray * list)
 {
   //
   // Detector specific actions at end of cycle
@@ -97,7 +97,7 @@ void AliTRDQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * li
   //AliInfo(Form("EndOfCycle", "Fitting RecPoints %d", task))
   TH1D *hist = new TH1D("fitHist", "", 200, -0.5, 199.5);
  
-  if (task == AliQA::kRECPOINTS) {
+  if (task == AliQAv1::kRECPOINTS) {
 
     //list->Print();
     
@@ -161,7 +161,7 @@ void AliTRDQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * li
   delete hist;
   
   // call the checker
-  AliQAChecker::Instance()->Run(AliQA::kTRD, task, list) ;    
+  AliQAChecker::Instance()->Run(AliQAv1::kTRD, task, list) ;    
 
   //watch.Stop();
   //watch.Print();
diff --git a/TRD/AliTRDQADataMaker.h b/TRD/AliTRDQADataMaker.h
index b0035a2ea82..5682004f54c 100644
--- a/TRD/AliTRDQADataMaker.h
+++ b/TRD/AliTRDQADataMaker.h
@@ -35,7 +35,7 @@ class AliTRDQADataMaker: public AliQADataMaker {
 
  private:
 
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list) ;
+  virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX task, TObjArray * list) ;
   virtual void InitHits() ; 
   virtual void InitESDs() ; 
   virtual void InitDigits() ; 
diff --git a/TRD/AliTRDQADataMakerRec.cxx b/TRD/AliTRDQADataMakerRec.cxx
index 4a525bdaed5..d2caf5d5ee9 100644
--- a/TRD/AliTRDQADataMakerRec.cxx
+++ b/TRD/AliTRDQADataMakerRec.cxx
@@ -51,7 +51,7 @@ ClassImp(AliTRDQADataMakerRec)
 
 //____________________________________________________________________________ 
   AliTRDQADataMakerRec::AliTRDQADataMakerRec() : 
-  AliQADataMakerRec(AliQA::GetDetName(AliQA::kTRD), "TRD Quality Assurance Data Maker")
+  AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kTRD), "TRD Quality Assurance Data Maker")
 {
   //
   // Default constructor
@@ -84,7 +84,7 @@ AliTRDQADataMakerRec& AliTRDQADataMakerRec::operator=(const AliTRDQADataMakerRec
 }
 
 //____________________________________________________________________________ 
-void AliTRDQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliTRDQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //
   // Detector specific actions at end of cycle
@@ -94,7 +94,7 @@ void AliTRDQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray
   
   AliInfo("End of TRD cycle");
   
-  if (task == AliQA::kRECPOINTS) {
+  if (task == AliQAv1::kRECPOINTS) {
     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
       TH1D * hist = new TH1D("fitHist", "", 200, -0.5, 199.5);
       //list[specie]->Print();
@@ -201,7 +201,7 @@ void AliTRDQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray
   // const char *suf[knbits] = {"TPCi", "TPCo", "TPCz", "TRDo", "TRDr", "TRDz"};
   //const char *sufRatio[4] = {"TRDrTRDo", "TRDoTPCo", "TRDrTPCo", "TRDzTPCo"};
 
-  if (task == AliQA::kESDS) {
+  if (task == AliQAv1::kESDS) {
     
     const Int_t knRatio = 4;
     const Int_t kN[knRatio] = {4,3,4,5};
@@ -228,7 +228,7 @@ void AliTRDQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray
     }
   }
   // call the checker
-  AliQAChecker::Instance()->Run(AliQA::kTRD, task, list) ;    
+  AliQAChecker::Instance()->Run(AliQAv1::kTRD, task, list) ;    
 }
 
 //____________________________________________________________________________ 
diff --git a/TRD/AliTRDQADataMakerRec.h b/TRD/AliTRDQADataMakerRec.h
index f7f00e0f5c0..330717b62f9 100644
--- a/TRD/AliTRDQADataMakerRec.h
+++ b/TRD/AliTRDQADataMakerRec.h
@@ -35,7 +35,7 @@ class AliTRDQADataMakerRec: public AliQADataMakerRec {
 
  private:
 
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list) ;
+  virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) ;
   virtual void InitESDs() ; 
   virtual void InitRecPoints() ; 
   virtual void InitRaws() ; 
diff --git a/TRD/AliTRDQADataMakerSim.cxx b/TRD/AliTRDQADataMakerSim.cxx
index 73909ca63ac..86dd97cc6eb 100644
--- a/TRD/AliTRDQADataMakerSim.cxx
+++ b/TRD/AliTRDQADataMakerSim.cxx
@@ -55,7 +55,7 @@ ClassImp(AliTRDQADataMakerSim)
 
 //____________________________________________________________________________ 
   AliTRDQADataMakerSim::AliTRDQADataMakerSim() : 
-  AliQADataMakerSim(AliQA::GetDetName(AliQA::kTRD), "TRD Quality Assurance Data Maker")
+  AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kTRD), "TRD Quality Assurance Data Maker")
 {
   //
   // Default constructor
@@ -88,7 +88,7 @@ AliTRDQADataMakerSim& AliTRDQADataMakerSim::operator=(const AliTRDQADataMakerSim
 }
 
 //____________________________________________________________________________ 
-void AliTRDQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliTRDQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //
   // Detector specific actions at end of cycle
@@ -97,7 +97,7 @@ void AliTRDQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray
   //AliInfo(Form("EndOfCycle", "Fitting RecPoints %d", task));
 
   // call the checker
-  AliQAChecker::Instance()->Run(AliQA::kTRD, task, list) ;    
+  AliQAChecker::Instance()->Run(AliQAv1::kTRD, task, list) ;    
 
 
 }
diff --git a/TRD/AliTRDQADataMakerSim.h b/TRD/AliTRDQADataMakerSim.h
index 2bc7e456045..e770a12306f 100644
--- a/TRD/AliTRDQADataMakerSim.h
+++ b/TRD/AliTRDQADataMakerSim.h
@@ -35,7 +35,7 @@ class AliTRDQADataMakerSim: public AliQADataMakerSim {
 
  private:
 
-  virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list) ;
+  virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) ;
   virtual void InitHits() ; 
   virtual void InitDigits() ; 
   virtual void InitSDigits() ;
diff --git a/TRD/AliTRDqaRecPoints.cxx b/TRD/AliTRDqaRecPoints.cxx
index 44d2d7c53d9..3bca2308802 100644
--- a/TRD/AliTRDqaRecPoints.cxx
+++ b/TRD/AliTRDqaRecPoints.cxx
@@ -87,7 +87,7 @@ void AliTRDqaRecPoints::Process(const char* filename)
   
   AliInfo("End of TRD cycle");
   
-  //if (task == AliQA::kRECPOINTS) {
+  //if (task == AliQAv1::kRECPOINTS) {
   
   TH1D *hist = new TH1D("fitHist", "", 200, -0.5, 199.5);
   //fHist->Print();
diff --git a/VZERO/AliVZEROQAChecker.cxx b/VZERO/AliVZEROQAChecker.cxx
index ec81c301f62..ede15c89d83 100644
--- a/VZERO/AliVZEROQAChecker.cxx
+++ b/VZERO/AliVZEROQAChecker.cxx
@@ -32,7 +32,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliVZEROQAChecker.h"
 #include "AliVZEROQADataMakerRec.h"
@@ -42,7 +42,7 @@
 ClassImp(AliVZEROQAChecker)
 
 //____________________________________________________________________________
-Double_t * AliVZEROQAChecker::Check(AliQA::ALITASK_t /*index*/)
+Double_t * AliVZEROQAChecker::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 * AliVZEROQAChecker::Check(AliQA::ALITASK_t /*index*/)
 }
 
 //__________________________________________________________________
-Double_t * AliVZEROQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list) 
+Double_t * AliVZEROQAChecker::Check(AliQAv1::ALITASK_t index, TObjArray ** list) 
 {
 
 // Main check function: Depending on the TASK, different checks will be applied
@@ -68,13 +68,13 @@ Double_t * AliVZEROQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
   Double_t * check = new Double_t[AliRecoParam::kNSpecies] ; 
   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.0){
         check[specie] =  CheckEntries(list[specie]);
     } else {
       //   Check for one disk missing (FATAL) or one ring missing (ERROR) in ESDs     
-      if(index == AliQA::kESD) 
+      if(index == AliQAv1::kESD) 
           check[specie] =  CheckEsds(list[specie]);
     } 
   }
@@ -188,44 +188,44 @@ Double_t AliVZEROQAChecker::CheckEsds(TObjArray * list) const
 } 
 
 //______________________________________________________________________________
-void AliVZEROQAChecker::Init(const AliQA::DETECTORINDEX_t det) 
+void AliVZEROQAChecker::Init(const AliQAv1::DETECTORINDEX_t det) 
 {
   // intialises QA and QA checker settings
-  AliQA::Instance(det) ; 
-  Float_t * hiValue = new Float_t[AliQA::kNBIT] ; 
-  Float_t * lowValue = new Float_t[AliQA::kNBIT] ;
-  lowValue[AliQA::kINFO]      = 0.5   ; 
-  hiValue[AliQA::kINFO]       = 1.0 ; 
-  lowValue[AliQA::kWARNING]   = 0.2 ; 
-  hiValue[AliQA::kWARNING]    = 0.5 ; 
-  lowValue[AliQA::kERROR]     = 0.0   ; 
-  hiValue[AliQA::kERROR]      = 0.2 ; 
-  lowValue[AliQA::kFATAL]     = -1.0   ; 
-  hiValue[AliQA::kFATAL]      = 0.0 ; 
+  AliQAv1::Instance(det) ; 
+  Float_t * hiValue = new Float_t[AliQAv1::kNBIT] ; 
+  Float_t * lowValue = new Float_t[AliQAv1::kNBIT] ;
+  lowValue[AliQAv1::kINFO]      = 0.5   ; 
+  hiValue[AliQAv1::kINFO]       = 1.0 ; 
+  lowValue[AliQAv1::kWARNING]   = 0.2 ; 
+  hiValue[AliQAv1::kWARNING]    = 0.5 ; 
+  lowValue[AliQAv1::kERROR]     = 0.0   ; 
+  hiValue[AliQAv1::kERROR]      = 0.2 ; 
+  lowValue[AliQAv1::kFATAL]     = -1.0   ; 
+  hiValue[AliQAv1::kFATAL]      = 0.0 ; 
   SetHiLo(hiValue, lowValue) ; 
 }
 
 //______________________________________________________________________________
-void AliVZEROQAChecker::SetQA(AliQA::ALITASK_t index, Double_t * value) const
+void AliVZEROQAChecker::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
 {
 // sets the QA word according to 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) ; 	
     }
   }
 }
diff --git a/VZERO/AliVZEROQAChecker.h b/VZERO/AliVZEROQAChecker.h
index 65866b371e2..c46c7cd45d6 100644
--- a/VZERO/AliVZEROQAChecker.h
+++ b/VZERO/AliVZEROQAChecker.h
@@ -30,15 +30,15 @@ class AliVZEROQAChecker: public AliQACheckerBase {
   AliVZEROQAChecker(const AliVZEROQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()) {;} // cpy ctor   
   virtual ~AliVZEROQAChecker() {;} // destructor
   
-  virtual void   Init(const AliQA::DETECTORINDEX_t det) ; 
+  virtual void   Init(const AliQAv1::DETECTORINDEX_t det) ; 
 
 protected:  
-  virtual  Double_t * Check(AliQA::ALITASK_t index, TObjArray ** list);
-  virtual  Double_t * Check(AliQA::ALITASK_t ) ; 
+  virtual  Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** list);
+  virtual  Double_t * Check(AliQAv1::ALITASK_t ) ; 
   Double_t CheckEntries(TObjArray * list) const ;
   Double_t CheckEsds(TObjArray * list) const;
   
-  virtual void SetQA(AliQA::ALITASK_t index, Double_t * value) const ;
+  virtual void SetQA(AliQAv1::ALITASK_t index, Double_t * value) const ;
   
 private:
   
diff --git a/VZERO/AliVZEROQADataMakerRec.cxx b/VZERO/AliVZEROQADataMakerRec.cxx
index 11d27d2c53f..e3d0cbc7896 100644
--- a/VZERO/AliVZEROQADataMakerRec.cxx
+++ b/VZERO/AliVZEROQADataMakerRec.cxx
@@ -49,7 +49,7 @@ ClassImp(AliVZEROQADataMakerRec)
            
 //____________________________________________________________________________ 
   AliVZEROQADataMakerRec::AliVZEROQADataMakerRec() : 
-	AliQADataMakerRec(AliQA::GetDetName(AliQA::kVZERO), "VZERO Quality Assurance Data Maker"),
+	AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kVZERO), "VZERO Quality Assurance Data Maker"),
 	fCalibData(0x0),
     fEvent(0)
     
@@ -118,16 +118,16 @@ AliVZEROCalibData* AliVZEROQADataMakerRec::GetCalibData() const
 
  
 //____________________________________________________________________________ 
-void AliVZEROQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliVZEROQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   // Detector specific actions at end of cycle
   // Does the QA checking
   
-  AliQAChecker::Instance()->Run(AliQA::kVZERO, task, list) ;
+  AliQAChecker::Instance()->Run(AliQAv1::kVZERO, task, list) ;
 
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
     SetEventSpecie(specie) ; 
-    if(task == AliQA::kRAWS){
+    if(task == AliQAv1::kRAWS){
   	  int nMaxBin = GetRawsData(kPedestalTimeInt0)->GetNbinsY();
       if(fCurrentCycle%nMaxBin==0) {
         GetRawsData(kPedestalTimeInt0)->Reset();
@@ -150,7 +150,7 @@ void AliVZEROQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArr
           delete hProj;
         }
       }
-    } else if (task == AliQA::kESDS) {
+    } else if (task == AliQAv1::kESDS) {
     }
   }
 }
@@ -679,37 +679,37 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
 	} // END of SWITCH : EVENT TYPE 
 	
 	fEvent++; 
-	TParameter<double> * p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kMultiV0A)->GetName()))) ; 
+	TParameter<double> * p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiV0A)->GetName()))) ; 
 	p->SetVal((double)mulV0A) ; 
 
-	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kMultiV0C)->GetName()))) ; 
+	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiV0C)->GetName()))) ; 
 	p->SetVal((double)mulV0C) ;                     
 
-	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kChargeV0A)->GetName()))) ; 
+	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0A)->GetName()))) ; 
 	p->SetVal((double)chargeV0A) ; 
 
-	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kChargeV0C)->GetName()))) ; 
+	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0C)->GetName()))) ; 
 	p->SetVal((double)chargeV0C) ;                     
 
-	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kChargeV0)->GetName()))) ; 
+	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0)->GetName()))) ; 
 	p->SetVal((double)(chargeV0A + chargeV0C)) ;                     
 	
-	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kRawMIPV0A)->GetName()))) ; 
+	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0A)->GetName()))) ; 
 	p->SetVal((double)mipV0A) ; 
 	
-	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kRawMIPV0C)->GetName()))) ; 
+	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0C)->GetName()))) ; 
 	p->SetVal((double)mipV0C) ;                     
 	
-	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kRawMIPV0)->GetName()))) ; 
+	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0)->GetName()))) ; 
 	p->SetVal((double)(mipV0A + mipV0C)) ;                     
 	
-	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kV0ATime)->GetName()))) ; 
+	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kV0ATime)->GetName()))) ; 
 	p->SetVal((double)timeV0A) ; 
 	
-	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kV0CTime)->GetName()))) ; 
+	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kV0CTime)->GetName()))) ; 
 	p->SetVal((double)timeV0C) ;                     
 	
-	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kDiffTime)->GetName()))) ; 
+	p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kDiffTime)->GetName()))) ; 
 	p->SetVal((double)diffTime) ;                     
 	
   	delete rawStream; rawStream = 0x0;      
diff --git a/VZERO/AliVZEROQADataMakerRec.h b/VZERO/AliVZEROQADataMakerRec.h
index c9271991c73..76ff6ee6616 100644
--- a/VZERO/AliVZEROQADataMakerRec.h
+++ b/VZERO/AliVZEROQADataMakerRec.h
@@ -52,7 +52,7 @@ class AliVZEROQADataMakerRec: public AliQADataMakerRec {
   AliVZEROCalibData *fCalibData;        //! calibration data
    
 private:
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
   virtual void   InitESDs() ; 
   virtual void   InitRaws() ; 
   virtual void   MakeESDs(AliESDEvent * esd) ;
diff --git a/VZERO/AliVZEROQADataMakerSim.cxx b/VZERO/AliVZEROQADataMakerSim.cxx
index 91e4bb20a83..d10d635b53b 100644
--- a/VZERO/AliVZEROQADataMakerSim.cxx
+++ b/VZERO/AliVZEROQADataMakerSim.cxx
@@ -41,7 +41,7 @@ ClassImp(AliVZEROQADataMakerSim)
            
 //____________________________________________________________________________ 
   AliVZEROQADataMakerSim::AliVZEROQADataMakerSim() : 
-  AliQADataMakerSim(AliQA::GetDetName(AliQA::kVZERO), "VZERO Quality Assurance Data Maker")
+  AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kVZERO), "VZERO Quality Assurance Data Maker")
 
 {
   // constructor
@@ -68,11 +68,11 @@ AliVZEROQADataMakerSim& AliVZEROQADataMakerSim::operator = (const AliVZEROQAData
   return *this;
 }
 //____________________________________________________________________________
-void AliVZEROQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliVZEROQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kVZERO, task, list) ;
+  AliQAChecker::Instance()->Run(AliQAv1::kVZERO, task, list) ;
 }
 
  
diff --git a/VZERO/AliVZEROQADataMakerSim.h b/VZERO/AliVZEROQADataMakerSim.h
index 46e2c2f6fbf..81f154588bb 100644
--- a/VZERO/AliVZEROQADataMakerSim.h
+++ b/VZERO/AliVZEROQADataMakerSim.h
@@ -30,7 +30,7 @@ class AliVZEROQADataMakerSim: public AliQADataMakerSim {
   virtual ~AliVZEROQADataMakerSim() {} // 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   MakeHits(TClonesArray* hits) ;
diff --git a/ZDC/AliZDCQAChecker.cxx b/ZDC/AliZDCQAChecker.cxx
index ca19f479206..5ff7daab9c7 100644
--- a/ZDC/AliZDCQAChecker.cxx
+++ b/ZDC/AliZDCQAChecker.cxx
@@ -28,20 +28,20 @@
 ClassImp(AliZDCQAChecker)
 
 //____________________________________________________________________________
-Double_t * AliZDCQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list) 
+Double_t * AliZDCQAChecker::Check(AliQAv1::ALITASK_t index, TObjArray ** list) 
 {
   // Checks the QA histograms on the input list: 
   //
   Double_t * test   = new Double_t[AliRecoParam::kNSpecies] ;
   Int_t *    ntests = new Int_t[AliRecoParam::kNSpecies]  ; 
-  const char* taskName = AliQA::GetAliTaskName(index);
+  const char* taskName = AliQAv1::GetAliTaskName(index);
   //
   
   //YS Int_t beamType=0; // 0 -> protons, 1 -> ions
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
     test[specie] = 1.0 ; 
     ntests[specie] = 0 ; 
-    if ( !AliQA::Instance()->IsEventSpecieSet(specie) ) 
+    if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) 
       continue ; 
     // ====================================================================
     // 	Checks for p-p events
@@ -59,7 +59,7 @@ Double_t * AliZDCQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
       while((hdata = dynamic_cast<TH1 *>(next()))){
         if(hdata){ 
           // -------------------------------------------------------------------
-          if(index == AliQA::kSIM){
+          if(index == AliQAv1::kSIM){
             //AliInfo(Form("\tAliZDCQAChecker-> checking histo %s",hdata->GetName()));
             // Check DIGITS histos
             if(!(strncmp(hdata->GetName(),"hDig",4))){
@@ -76,7 +76,7 @@ Double_t * AliZDCQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
               }
             }
             // -------------------------------------------------------------------
-          } else if(index == AliQA::kRAW) {
+          } else if(index == AliQAv1::kRAW) {
             if(hdata->GetEntries()!=0){
               if(hdata->GetMean()>10.) 
                 test[specie] += 1.; 
@@ -85,7 +85,7 @@ Double_t * AliZDCQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
               ntests[specie]++;
             }
             // -------------------------------------------------------------------
-          } else if(index == AliQA::kESD) {
+          } else if(index == AliQAv1::kESD) {
             Int_t    esdInd=0;
             if(hdata->GetEntries()!=0){
               if(esdInd>1){
@@ -131,7 +131,7 @@ Double_t * AliZDCQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
           Float_t  res=0.;
           Int_t    testgood=0;
           // -------------------------------------------------------------------
-          if(index == AliQA::kSIM){
+          if(index == AliQAv1::kSIM){
             Int_t    digInd=0;
             // Check DIGITS histos
             if (!(strncmp(hdata->GetName(),"hDig",4))){
@@ -257,7 +257,7 @@ Double_t * AliZDCQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
             }
           }
           // -------------------------------------------------------------------
-          else if(index == AliQA::kRAW){
+          else if(index == AliQAv1::kRAW){
             Int_t    rawInd=0;
             // [1] check response of ZNC vs. ZNA
             if(rawInd==0 || rawInd==1){
@@ -362,7 +362,7 @@ Double_t * AliZDCQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
             rawInd++;
           }
           // -------------------------------------------------------------------
-          else if(index == AliQA::kESD){
+          else if(index == AliQAv1::kESD){
             Double_t eneQZNC, eneQZNA ;  
             Double_t eneQZPC, eneQZPA ;  
             Double_t eneCZNC, eneCZNA ;  
diff --git a/ZDC/AliZDCQAChecker.h b/ZDC/AliZDCQAChecker.h
index 56c21ef0413..b8bb7cdbc92 100644
--- a/ZDC/AliZDCQAChecker.h
+++ b/ZDC/AliZDCQAChecker.h
@@ -22,8 +22,8 @@ class AliZDCQAChecker: public AliQACheckerBase {
 
  protected:
 
-  virtual Double_t * Check(AliQA::ALITASK_t index, TObjArray ** list) ;
-  virtual Double_t * Check(AliQA::ALITASK_t /*index*/) { return NULL ; }  
+  virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** list) ;
+  virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/) { return NULL ; }  
   
   ClassDef(AliZDCQAChecker,1)  // description 
 
diff --git a/ZDC/AliZDCQADataMaker.cxx b/ZDC/AliZDCQADataMaker.cxx
index 2d9766d8988..60a00354993 100644
--- a/ZDC/AliZDCQADataMaker.cxx
+++ b/ZDC/AliZDCQADataMaker.cxx
@@ -35,7 +35,7 @@ ClassImp(AliZDCQADataMaker)
            
 //____________________________________________________________________________ 
   AliZDCQADataMaker::AliZDCQADataMaker() : 
-      AliQADataMaker(AliQA::GetDetName(AliQA::kZDC), "ZDC Quality Assurance Data Maker"),
+      AliQADataMaker(AliQAv1::GetDetName(AliQAv1::kZDC), "ZDC Quality Assurance Data Maker"),
       fHits("AliZDCHit", 1000),
       fDigits("AliZDCDigit", 1000)
 
@@ -594,8 +594,8 @@ void AliZDCQADataMaker::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliZDCQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list)
+void AliZDCQADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kZDC, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kZDC, task, list) ;  
diff --git a/ZDC/AliZDCQADataMaker.h b/ZDC/AliZDCQADataMaker.h
index 15cabc7888f..801d5c6307d 100644
--- a/ZDC/AliZDCQADataMaker.h
+++ b/ZDC/AliZDCQADataMaker.h
@@ -39,7 +39,7 @@ class AliZDCQADataMaker: public AliQADataMaker {
   virtual void  MakeRaws(AliRawReader* rawReader);
   virtual void  MakeESDs(AliESDEvent * esd);	     
   virtual void  StartOfDetectorCycle();
-  virtual void  EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);
+  virtual void  EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
   //
   TClonesArray * fHits; 	//! Array containing ZDC hits
   TClonesArray * fDigits; 	//! Array containing ZDC digits
diff --git a/ZDC/AliZDCQADataMakerRec.cxx b/ZDC/AliZDCQADataMakerRec.cxx
index b66919a396f..8d6c57763f8 100644
--- a/ZDC/AliZDCQADataMakerRec.cxx
+++ b/ZDC/AliZDCQADataMakerRec.cxx
@@ -43,7 +43,7 @@ ClassImp(AliZDCQADataMakerRec)
            
 //____________________________________________________________________________ 
   AliZDCQADataMakerRec::AliZDCQADataMakerRec() : 
-  AliQADataMakerRec(AliQA::GetDetName(AliQA::kZDC), "ZDC Quality Assurance Data Maker")
+  AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kZDC), "ZDC Quality Assurance Data Maker")
 {
   // ctor
 }
@@ -364,10 +364,10 @@ void AliZDCQADataMakerRec::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliZDCQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliZDCQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   //Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kZDC, task, list) ;  
+  AliQAChecker::Instance()->Run(AliQAv1::kZDC, task, list) ;  
 }
 
diff --git a/ZDC/AliZDCQADataMakerRec.h b/ZDC/AliZDCQADataMakerRec.h
index d0586de080d..4a35a69f440 100644
--- a/ZDC/AliZDCQADataMakerRec.h
+++ b/ZDC/AliZDCQADataMakerRec.h
@@ -28,7 +28,7 @@ class AliZDCQADataMakerRec: public AliQADataMakerRec {
   virtual void   MakeRaws(AliRawReader* rawReader) ; 
   virtual void   MakeESDs(AliESDEvent * esd) ;
   virtual void   StartOfDetectorCycle() ; 
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list) ;
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) ;
 
   ClassDef(AliZDCQADataMakerRec,1)  // description 
 
diff --git a/ZDC/AliZDCQADataMakerSim.cxx b/ZDC/AliZDCQADataMakerSim.cxx
index fbbb6c89b3b..604b1da13a3 100644
--- a/ZDC/AliZDCQADataMakerSim.cxx
+++ b/ZDC/AliZDCQADataMakerSim.cxx
@@ -34,7 +34,7 @@ ClassImp(AliZDCQADataMakerSim)
            
 //____________________________________________________________________________ 
   AliZDCQADataMakerSim::AliZDCQADataMakerSim() : 
-      AliQADataMakerSim(AliQA::GetDetName(AliQA::kZDC), "ZDC Quality Assurance Data Maker"),
+      AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kZDC), "ZDC Quality Assurance Data Maker"),
       fHits(0),
       fDigit(0)
 {
@@ -310,9 +310,9 @@ void AliZDCQADataMakerSim::StartOfDetectorCycle()
 }
 
 //____________________________________________________________________________ 
-void AliZDCQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliZDCQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 {
   // Detector specific actions at end of cycle
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQA::kZDC, task, list);  
+  AliQAChecker::Instance()->Run(AliQAv1::kZDC, task, list);  
 }
diff --git a/ZDC/AliZDCQADataMakerSim.h b/ZDC/AliZDCQADataMakerSim.h
index 7ec17716a7b..1e7cf0771c4 100644
--- a/ZDC/AliZDCQADataMakerSim.h
+++ b/ZDC/AliZDCQADataMakerSim.h
@@ -32,7 +32,7 @@ class AliZDCQADataMakerSim: public AliQADataMakerSim {
   virtual void   MakeSDigits(TClonesArray * /*sdigits*/) {;} 
   virtual void   MakeSDigits(TTree * /*sdigTree*/) {;}
   virtual void   StartOfDetectorCycle(); 
-  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list);
+  virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list);
   //
   TClonesArray   *fHits; 	//! Array containing ZDC hits
   AliZDCDigit    *fDigit; 	//! Pointer to digit in tree