Changing name QualAss to QA
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 10 Oct 2007 08:59:55 +0000 (08:59 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 10 Oct 2007 08:59:55 +0000 (08:59 +0000)
14 files changed:
STEER/AliModule.cxx
STEER/AliModule.h
STEER/AliQA.cxx [moved from STEER/AliQualAss.cxx with 84% similarity]
STEER/AliQA.h [moved from STEER/AliQualAss.h with 83% similarity]
STEER/AliQAChecker.cxx [moved from STEER/AliQualAssChecker.cxx with 64% similarity]
STEER/AliQAChecker.h [moved from STEER/AliQualAssChecker.h with 64% similarity]
STEER/AliQACheckerBase.cxx [moved from STEER/AliQualAssCheckerBase.cxx with 76% similarity]
STEER/AliQACheckerBase.h [moved from STEER/AliQualAssCheckerBase.h with 61% similarity]
STEER/AliQADataMaker.cxx [moved from STEER/AliQualAssDataMaker.cxx with 76% similarity]
STEER/AliQADataMaker.h [moved from STEER/AliQualAssDataMaker.h with 84% similarity]
STEER/AliReconstruction.cxx
STEER/AliReconstruction.h
STEER/STEERLinkDef.h
STEER/libSTEER.pkg

index 72092ae..f11805c 100644 (file)
@@ -103,6 +103,7 @@ AliModule::AliModule(const char* name,const char *title):
   // Add this Module to the global list of Modules in Run.
   //
   // Get the Module numeric ID
+
   Int_t id = gAlice->GetModuleID(name);
   if (id>=0) {
     // Module already added !
index 0af7490..1a8540e 100644 (file)
@@ -98,7 +98,7 @@ public:
   virtual void        Digits2Raw();
   virtual void        Raw2Digits()  {}
   virtual Bool_t      Raw2SDigits(AliRawReader*) {return kFALSE;}
-  virtual void        QualAssDataMaker (const char *) {} 
+  virtual void        QADataMaker (const char *) {} 
   virtual void        Browse(TBrowser *) {} //PH Do we need it?
   virtual void        CreateGeometry() {}
   virtual void        CreateMaterials() {}
similarity index 84%
rename from STEER/AliQualAss.cxx
rename to STEER/AliQA.cxx
index 752351e..e515f56 100644 (file)
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQualAss.h"
+#include "AliQA.h"
 
 
-ClassImp(AliQualAss)
-  AliQualAss * AliQualAss::fgQA        = 0x0 ;
-  TFile      * AliQualAss::fgDataFile  = 0x0 ;   
-  TString      AliQualAss::fgDataName  = "QA" ;   
-  TString      AliQualAss::fgDetNames[]  = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD",
+ClassImp(AliQA)
+  AliQA * AliQA::fgQA        = 0x0 ;
+  TFile      * AliQA::fgDataFile  = 0x0 ;   
+  TString      AliQA::fgDataName  = "QA" ;   
+  TString      AliQA::fgDetNames[]  = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD",
                                        "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"} ;   
-  TString      AliQualAss::fgTaskNames[]  = {"Raws", "Hits", "SDigits", "Digits", "RecPoints", "TrackSegments", "RecParticles", "ESDs"} ;   
+  TString      AliQA::fgTaskNames[]  = {"Raws", "Hits", "SDigits", "Digits", "RecPoints", "TrackSegments", "RecParticles", "ESDs"} ;   
 
 //____________________________________________________________________________
-AliQualAss::AliQualAss() : 
+AliQA::AliQA() : 
   TNamed("", ""), 
   fQA(0x0), 
   fDet(kNULLDET),
@@ -61,7 +61,7 @@ AliQualAss::AliQualAss() :
 }
 
 //____________________________________________________________________________
-AliQualAss::AliQualAss(const AliQualAss& qa) :
+AliQA::AliQA(const AliQA& qa) :
   TNamed(qa),
   fQA(qa.fQA), 
   fDet(qa.fDet),
@@ -71,17 +71,17 @@ AliQualAss::AliQualAss(const AliQualAss& qa) :
 }
 
 //_____________________________________________________________________________
-AliQualAss& AliQualAss::operator = (const AliQualAss& qa)
+AliQA& AliQA::operator = (const AliQA& qa)
 {
 // assignment operator
 
-  this->~AliQualAss();
-  new(this) AliQualAss(qa);
+  this->~AliQA();
+  new(this) AliQA(qa);
   return *this;
 }
 
 //_______________________________________________________________
-AliQualAss::AliQualAss(const DETECTORINDEX det) :
+AliQA::AliQA(const DETECTORINDEX det) :
   TNamed("QA", "Quality Assurance status"), 
   fQA(new ULong_t[kNDET]), 
   fDet(det),
@@ -98,7 +98,7 @@ AliQualAss::AliQualAss(const DETECTORINDEX det) :
 }
   
 //_______________________________________________________________
-AliQualAss::AliQualAss(const ALITASK tsk) :
+AliQA::AliQA(const ALITASK tsk) :
   TNamed("QA", "Quality Assurance status"), 
   fQA(new ULong_t[kNDET]), 
   fDet(kNULLDET),
@@ -115,14 +115,14 @@ AliQualAss::AliQualAss(const ALITASK tsk) :
 }
 
 //____________________________________________________________________________
-AliQualAss::~AliQualAss() 
+AliQA::~AliQA() 
 {
   // dtor  
   delete[] fQA ;
 }
 
 //_______________________________________________________________
-const Bool_t AliQualAss::CheckRange(DETECTORINDEX det) const
+const Bool_t AliQA::CheckRange(DETECTORINDEX det) const
 { 
   // check if detector is in given detector range: 0-kNDET
 
@@ -133,7 +133,7 @@ const Bool_t AliQualAss::CheckRange(DETECTORINDEX det) const
 }
 
 //_______________________________________________________________
-const Bool_t AliQualAss::CheckRange(ALITASK task) const
+const Bool_t AliQA::CheckRange(ALITASK task) const
 { 
   // check if task is given taskk range: 0:kNTASK
   Bool_t rv = ( task < kRAW || task > kNTASK )  ? kFALSE : kTRUE ;
@@ -143,7 +143,7 @@ const Bool_t AliQualAss::CheckRange(ALITASK task) const
 }
 
 //_______________________________________________________________
-const Bool_t AliQualAss::CheckRange(QABIT bit) const
+const Bool_t AliQA::CheckRange(QABIT bit) const
 { 
   // check if bit is in given bit range: 0-kNBit
 
@@ -155,7 +155,7 @@ const Bool_t AliQualAss::CheckRange(QABIT bit) const
 
 
 //_______________________________________________________________
-TFile * AliQualAss::GetQADMOutFile(const char * name, const Int_t run, const Int_t cycle) 
+TFile * AliQA::GetQADMOutFile(const char * name, const Int_t run, const Int_t cycle) 
 {
   // opens the file to store the detectors Quality Assurance Data Maker results
   char temp[100] ; 
@@ -180,7 +180,7 @@ TFile * AliQualAss::GetQADMOutFile(const char * name, const Int_t run, const Int
 } 
 
 //_______________________________________________________________
-const char * AliQualAss::GetDetName(Int_t det) 
+const char * AliQA::GetDetName(Int_t det) 
 {
        // returns the detector name corresponding to a given index (needed in a loop)
 
@@ -191,7 +191,7 @@ const char * AliQualAss::GetDetName(Int_t det)
 }
 
 //_______________________________________________________________
-const char * AliQualAss::GetAliTaskName(ALITASK tsk)
+const char * AliQA::GetAliTaskName(ALITASK tsk)
 {
   // returns the char name corresponding to module index
   TString tskName ;
@@ -221,7 +221,7 @@ const char * AliQualAss::GetAliTaskName(ALITASK tsk)
 }
 
 //_______________________________________________________________
-const Bool_t AliQualAss::CheckFatal() const
+const Bool_t AliQA::CheckFatal() const
 {
   // check if any FATAL status is set
   Bool_t rv = kFALSE ;
@@ -232,7 +232,7 @@ const Bool_t AliQualAss::CheckFatal() const
 }
 
 //_______________________________________________________________
-const Bool_t AliQualAss::IsSet(DETECTORINDEX det, ALITASK tsk, QABIT bit) const
+const Bool_t AliQA::IsSet(DETECTORINDEX det, ALITASK tsk, QABIT bit) const
 {
   // Checks is the requested bit is set
 
@@ -248,7 +248,7 @@ const Bool_t AliQualAss::IsSet(DETECTORINDEX det, ALITASK tsk, QABIT bit) const
 }
 
 //_______________________________________________________________
-AliQualAss * AliQualAss::Instance()
+AliQA * AliQA::Instance()
 {
   // Get an instance of the singleton.
   // Object must have been instantiated with Instance(ALITASK) first
@@ -257,18 +257,18 @@ AliQualAss * AliQualAss::Instance()
 }
 
 //_______________________________________________________________
-AliQualAss * AliQualAss::Instance(const DETECTORINDEX det)
+AliQA * AliQA::Instance(const DETECTORINDEX det)
 {
   // Get an instance of the singleton. The only authorized way to call the ctor
   
   if ( ! fgQA)
-    fgQA = new AliQualAss(det) ;
+    fgQA = new AliQA(det) ;
   fgQA->Set(det) ;
   return fgQA ;
 }
 
 //_______________________________________________________________
-AliQualAss * AliQualAss::Instance(const ALITASK tsk)
+AliQA * AliQA::Instance(const ALITASK tsk)
 {
   // get an instance of the singleton.
 
@@ -277,10 +277,10 @@ AliQualAss * AliQualAss::Instance(const ALITASK tsk)
     case kNULLTASK:
       break ;
        case kRAW:
-      fgQA = new AliQualAss(tsk) ;
+      fgQA = new AliQA(tsk) ;
       break ;
        case kSIM:
-      fgQA = new AliQualAss(tsk) ;
+      fgQA = new AliQA(tsk) ;
       break ;
     case kREC:
       printf("fgQA = gAlice->GetQA()") ;
@@ -300,7 +300,7 @@ AliQualAss * AliQualAss::Instance(const ALITASK tsk)
 }
 
 //_______________________________________________________________
-const ULong_t AliQualAss::Offset(ALITASK tsk) const
+const ULong_t AliQA::Offset(ALITASK tsk) const
 {
   // Calculates the bit offset for a given module (SIM, REC, ESD, ANA)
 
@@ -333,7 +333,7 @@ const ULong_t AliQualAss::Offset(ALITASK tsk) const
 }
 
 //_______________________________________________________________
-void AliQualAss::Set(QABIT bit)
+void AliQA::Set(QABIT bit)
 {
   // Set the status bit of the current detector in the current module
   
@@ -341,7 +341,7 @@ void AliQualAss::Set(QABIT bit)
 }
 
 //_______________________________________________________________
-void AliQualAss::SetStatusBit(DETECTORINDEX det, ALITASK tsk, QABIT bit)
+void AliQA::SetStatusBit(DETECTORINDEX det, ALITASK tsk, QABIT bit)
 {
  // Set the status bit for a given detector and a given task
 
@@ -357,7 +357,7 @@ void AliQualAss::SetStatusBit(DETECTORINDEX det, ALITASK tsk, QABIT bit)
 }
 
 //_______________________________________________________________
-void AliQualAss::ShowAll() const
+void AliQA::ShowAll() const
 {
   // dispplay the QA status word
   Int_t index ;
@@ -366,7 +366,7 @@ void AliQualAss::ShowAll() const
 }
 
 //_______________________________________________________________
-void AliQualAss::ShowStatus(DETECTORINDEX det) const
+void AliQA::ShowStatus(DETECTORINDEX det) const
 {
   // Prints the full QA status of a given detector
   CheckRange(det) ;
similarity index 83%
rename from STEER/AliQualAss.h
rename to STEER/AliQA.h
index 88e8758..9c11de7 100644 (file)
@@ -1,5 +1,5 @@
-#ifndef ALIQualAss_H
-#define ALIQualAss_H
+#ifndef ALIQA_H
+#define ALIQA_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
@@ -14,7 +14,7 @@ class TFile ;
 
 #include "AliLog.h"
 
-class AliQualAss : public TNamed {
+class AliQA : public TNamed {
 public:
 
   enum DETECTORINDEX {
@@ -33,16 +33,16 @@ public:
   };
   
  // Creators - destructors
-  AliQualAss(); // beware singleton, not to be used
-  AliQualAss(const ALITASK tsk) ;
-  AliQualAss(const DETECTORINDEX det) ;
-  AliQualAss(const AliQualAss& qa) ;   
-  AliQualAss& operator = (const AliQualAss& qa) ;
-  virtual ~AliQualAss();
+  AliQA(); // beware singleton, not to be used
+  AliQA(const ALITASK tsk) ;
+  AliQA(const DETECTORINDEX det) ;
+  AliQA(const AliQA& qa) ;   
+  AliQA& operator = (const AliQA& qa) ;
+  virtual ~AliQA();
  
-  static  AliQualAss *   Instance() ;
-  static  AliQualAss *   Instance(const DETECTORINDEX det) ;
-  static  AliQualAss *   Instance(const ALITASK tsk) ;
+  static  AliQA *   Instance() ;
+  static  AliQA *   Instance(const DETECTORINDEX det) ;
+  static  AliQA *   Instance(const ALITASK tsk) ;
   const Bool_t           CheckFatal() const ;
   static const char *    GetAliTaskName(ALITASK tsk) ;
   static const char *    GetDataName() { return fgDataName.Data() ; }
@@ -72,7 +72,7 @@ private:
   void                 SetStatus(DETECTORINDEX det, UShort_t status) { fQA[det] = status ; }
   void                 SetStatusBit(DETECTORINDEX det, ALITASK tsk, QABIT bit) ;
 
-  static AliQualAss *fgQA         ; // pointer to the instance of the singleton
+  static AliQA *fgQA              ; // pointer to the instance of the singleton
   ULong_t    *       fQA          ; //[kNDET] the status word 4 bits for SIM, REC, ESD, ANA each
   DETECTORINDEX      fDet         ; //!  the current detector (ITS, TPC, ....)
   ALITASK            fTask        ; //!  the current environment (SIM, REC, ESD, ANA)
@@ -80,6 +80,7 @@ private:
   static TString     fgDataName   ; //! the name of the file where the quality assurance maker store their results
   static TString     fgDetNames[] ; //! list of detector names   
   static TString     fgTaskNames[]; //! list of tasks names   
- ClassDef(AliQualAss,1)  //ALICE Quality Assurance Object
+
+ ClassDef(AliQA,1)  //ALICE Quality Assurance Object
 };
 #endif
similarity index 64%
rename from STEER/AliQualAssChecker.cxx
rename to STEER/AliQAChecker.cxx
index 496b2c9..8967d5f 100644 (file)
@@ -23,9 +23,9 @@
 
 #include "AliLog.h"
 #include "AliModule.h" 
-#include "AliQualAss.h"
-#include "AliQualAssChecker.h"
-#include "AliQualAssCheckerBase.h"
+#include "AliQA.h"
+#include "AliQAChecker.h"
+#include "AliQACheckerBase.h"
 
 #include <TKey.h>
 #include <TObjArray.h>
 #include <TSystem.h> 
 #include <TList.h>
 
-ClassImp(AliQualAssChecker)
-  AliQualAssChecker * AliQualAssChecker::fgQAChecker = 0x0 ;
-  TFile   * AliQualAssChecker::fgQAResultFile        = 0x0 ;  
-  TString   AliQualAssChecker::fgQAResultDirName     = "local://RUN/";  
-  TString   AliQualAssChecker::fgQAResultFileName    = "QA.root" ; 
+ClassImp(AliQAChecker)
+  AliQAChecker * AliQAChecker::fgQAChecker = 0x0 ;
+  TFile   * AliQAChecker::fgQAResultFile        = 0x0 ;  
+  TString   AliQAChecker::fgQAResultDirName     = "local://RUN/";  
+  TString   AliQAChecker::fgQAResultFileName    = "QA.root" ; 
 
 //_____________________________________________________________________________
-AliQualAssChecker::AliQualAssChecker(const char* name, const char* title) :
+AliQAChecker::AliQAChecker(const char* name, const char* title) :
   TNamed(name, title),
   fDataFile(0x0), 
   fRefDirName("./Ref/"), 
@@ -51,7 +51,7 @@ AliQualAssChecker::AliQualAssChecker(const char* name, const char* title) :
   fFoundDetectors(".")
 {
   // ctor: initialise checkers and open the data file   
-  for (Int_t det = 0 ; det < AliQualAss::kNDET ; det++) 
+  for (Int_t det = 0 ; det < AliQA::kNDET ; det++) 
     fCheckers[det] = NULL ; 
   
   GetDataFile() ; 
@@ -59,7 +59,7 @@ AliQualAssChecker::AliQualAssChecker(const char* name, const char* title) :
 }
 
 //_____________________________________________________________________________
-AliQualAssChecker::AliQualAssChecker(const AliQualAssChecker& qac) :
+AliQAChecker::AliQAChecker(const AliQAChecker& qac) :
   TNamed(qac),
   fDataFile(qac.fDataFile), 
   fRefDirName(qac.fRefDirName), 
@@ -68,40 +68,40 @@ AliQualAssChecker::AliQualAssChecker(const AliQualAssChecker& qac) :
 {
   // copy constructor
   
-  for (Int_t det = 0 ; det < AliQualAss::kNDET ; det++) 
+  for (Int_t det = 0 ; det < AliQA::kNDET ; det++) 
     fCheckers[det] = NULL ; 
 }
 
 //_____________________________________________________________________________
-AliQualAssChecker& AliQualAssChecker::operator = (const AliQualAssChecker& qac)
+AliQAChecker& AliQAChecker::operator = (const AliQAChecker& qac)
 {
 // assignment operator
 
-  this->~AliQualAssChecker();
-  new(this) AliQualAssChecker(qac);
+  this->~AliQAChecker();
+  new(this) AliQAChecker(qac);
   return *this;
 }
 
 //_____________________________________________________________________________
-AliQualAssChecker::~AliQualAssChecker()
+AliQAChecker::~AliQAChecker()
 {
 // clean up
   delete [] fCheckers ; 
 }
 
 //_____________________________________________________________________________
-TFile * AliQualAssChecker:: GetDataFile()
+TFile * AliQAChecker:: GetDataFile()
 {
   // Open if necessary the Data file and return its pointer
 
   if (!fDataFile) 
-       if  (gSystem->AccessPathName(AliQualAss::GetDataName()))
-     fDataFile =  TFile::Open(AliQualAss::GetDataName()) ;
+       if  (gSystem->AccessPathName(AliQA::GetDataName()))
+     fDataFile =  TFile::Open(AliQA::GetDataName()) ;
   return fDataFile ; 
 }
 
 //_____________________________________________________________________________
-TFile * AliQualAssChecker:: GetQAResultFile() 
+TFile * AliQAChecker:: GetQAResultFile() 
 {
   // Check if file to store QA exists, if not create it
 
@@ -125,36 +125,36 @@ TFile * AliQualAssChecker:: GetQAResultFile()
 }
 
 //_____________________________________________________________________________
-  AliQualAssCheckerBase * AliQualAssChecker::GetDetQualAssChecker(Int_t det)
+  AliQACheckerBase * AliQAChecker::GetDetQAChecker(Int_t det)
 {
   // Gets the Quality Assurance checker for the detector specified by its name
   
   if (fCheckers[det]) 
     return fCheckers[det];
 
- TString detName(AliQualAss::GetDetName(det)) ; 
+ TString detName(AliQA::GetDetName(det)) ; 
 
   AliInfo(Form("Retrieving QA checker for %s", detName.Data())) ; 
   TPluginManager* pluginManager = gROOT->GetPluginManager() ;
-  TString qacName = "Ali" + detName + "QualAssChecker" ;
+  TString qacName = "Ali" + detName + "QAChecker" ;
 
-  AliQualAssCheckerBase * qac = NULL ;
+  AliQACheckerBase * qac = NULL ;
   // first check if a plugin is defined for the quality assurance checker
-  TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQualAssChecker", detName.Data());
+  TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQAChecker", detName.Data());
   // if not, add a plugin for it
   if (!pluginHandler) {
     //AliInfo(Form("defining plugin for %s", qacName.Data()));
     TString libs = gSystem->GetLibraries();
  
    if (libs.Contains("lib" + detName + "base.so") || (gSystem->Load("lib" + detName + "base.so") >= 0))
-      pluginManager->AddHandler("AliQualAssChecker", detName, qacName, detName + "qac", qacName + "()");
+      pluginManager->AddHandler("AliQAChecker", detName, qacName, detName + "qac", qacName + "()");
     else 
-      pluginManager->AddHandler("AliQualAssChecker", detName, qacName, detName, qacName + "()");
+      pluginManager->AddHandler("AliQAChecker", detName, qacName, detName, qacName + "()");
 
-   pluginHandler = pluginManager->FindHandler("AliQualAssChecker", detName);
+   pluginHandler = pluginManager->FindHandler("AliQAChecker", detName);
 
   if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) 
-    qac = (AliQualAssCheckerBase *) pluginHandler->ExecPlugin(0);
+    qac = (AliQACheckerBase *) pluginHandler->ExecPlugin(0);
   
   if (qac) 
     fCheckers[det] = qac ; 
@@ -165,7 +165,7 @@ TFile * AliQualAssChecker:: GetQAResultFile()
 
 
 //_____________________________________________________________________________
-TDirectory * AliQualAssChecker::GetRefSubDir(const char * det, const char * task)     
+TDirectory * AliQAChecker::GetRefSubDir(const char * det, const char * task)     
 { 
   // Opens and returns the file with the reference data 
   TFile * f = TFile::Open(fRefDirName, "READ") ;
@@ -184,16 +184,16 @@ TDirectory * AliQualAssChecker::GetRefSubDir(const char * det, const char * task
 }
 
 //_____________________________________________________________________________
-AliQualAssChecker * AliQualAssChecker::Instance()
+AliQAChecker * AliQAChecker::Instance()
 {
        // returns unique instance of the checker
   if ( ! fgQAChecker ) 
-   fgQAChecker = new AliQualAssChecker() ; 
+   fgQAChecker = new AliQAChecker() ; 
   return fgQAChecker ;  
 }
 
 //_____________________________________________________________________________
-Bool_t AliQualAssChecker::Run()
+Bool_t AliQAChecker::Run()
 {
   // run the Quality Assurance Checker for all tasks Hits, SDigits, Digits, recpoints, tracksegments, recparticles and ESDs
   // starting from data in file
@@ -213,8 +213,8 @@ Bool_t AliQualAssChecker::Run()
     TString detName ; 
     TString detNameQA(detKey->GetName()) ; 
     Int_t det ; 
-    for ( det = 0; det < AliQualAss::kNDET ; det++) {
-      detName = AliQualAss::GetDetName(det) ; 
+    for ( det = 0; det < AliQA::kNDET ; det++) {
+      detName = AliQA::GetDetName(det) ; 
       if (detNameQA.Contains(detName)) {
        fFoundDetectors+=detName ; 
        fFoundDetectors+="." ;          
@@ -231,36 +231,36 @@ Bool_t AliQualAssChecker::Run()
       AliInfo(Form("Found %s", taskName.Data())) ;
       TDirectory * taskDir = detDir->GetDirectory(taskName.Data()) ; 
       taskDir->cd() ; 
-      AliQualAssCheckerBase * qac = GetDetQualAssChecker(det) ; 
+      AliQACheckerBase * qac = GetDetQAChecker(det) ; 
       if (qac)
                AliInfo(Form("QA checker found for %s", detName.Data())) ; 
       if (!qac)
                AliFatal(Form("QA checker not found for %s", detName.Data())) ; 
-      AliQualAss::ALITASK index = AliQualAss::kNULLTASK ; 
-      if ( taskName == AliQualAss::GetTaskName(AliQualAss::kHITS) ) 
-               index = AliQualAss::kSIM ; 
-      if ( taskName == AliQualAss::GetTaskName(AliQualAss::kSDIGITS) ) 
-               index = AliQualAss::kSIM ; 
-      if ( taskName == AliQualAss::GetTaskName(AliQualAss::kDIGITS) ) 
-               index = AliQualAss::kSIM ; 
-      if ( taskName == AliQualAss::GetTaskName(AliQualAss::kRECPOINTS) ) 
-               index = AliQualAss::kREC ; 
-      if ( taskName == AliQualAss::GetTaskName(AliQualAss::kTRACKSEGMENTS) ) 
-               index = AliQualAss::kREC ; 
-      if ( taskName == AliQualAss::GetTaskName(AliQualAss::kRECPARTICLES) ) 
-               index = AliQualAss::kREC ; 
-      if ( taskName == AliQualAss::GetTaskName(AliQualAss::kESDS) ) 
-               index = AliQualAss::kESD ; 
-      qac->Init(AliQualAss::DETECTORINDEX(det)) ; 
+      AliQA::ALITASK 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(det)) ; 
       qac->SetRefandData(GetRefSubDir(detNameQA.Data(), taskName.Data()), taskDir) ; 
       qac->Run(index) ; 
     }
  }
   AliInfo("QA performed for following detectors:") ; 
-  for ( Int_t det = 0; det < AliQualAss::kNDET; det++) {
-    if (fFoundDetectors.Contains(AliQualAss::GetDetName(det))) {
-      printf("%s, ",AliQualAss::GetDetName(det)) ; 
-      fFoundDetectors.ReplaceAll(AliQualAss::GetDetName(det), "") ; 
+  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), "") ; 
     }  
   }
   printf("\n") ; 
@@ -271,36 +271,36 @@ Bool_t AliQualAssChecker::Run()
 }
 
 //_____________________________________________________________________________
-Bool_t AliQualAssChecker::Run(AliQualAss::DETECTORINDEX det, AliQualAss::TASKINDEX task, TList * list)
+Bool_t AliQAChecker::Run(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task, TList * list)
 {
   // run the Quality Assurance Checker for detector det, for task task starting from data in list
 
-  AliQualAssCheckerBase * qac = GetDetQualAssChecker(det) ; 
+  AliQACheckerBase * qac = GetDetQAChecker(det) ; 
   if (qac)
-    AliInfo(Form("QA checker found for %s", AliQualAss::GetDetName(det).Data())) ;
+    AliInfo(Form("QA checker found for %s", AliQA::GetDetName(det).Data())) ;
   if (!qac)
-       AliFatal(Form("QA checker not found for %s", AliQualAss::GetDetName(det).Data())) ; 
+       AliFatal(Form("QA checker not found for %s", AliQA::GetDetName(det).Data())) ; 
   
-  AliQualAss::ALITASK index = AliQualAss::kNULLTASK ; 
-  if ( task == AliQualAss::kRAWS ) 
-               index = AliQualAss::kRAW ; 
-  else if ( task == AliQualAss::kHITS ) 
-               index = AliQualAss::kSIM ; 
-  else if ( task == AliQualAss::kSDIGITS ) 
-               index = AliQualAss::kSIM ; 
-  else if ( task == AliQualAss::kDIGITS ) 
-               index = AliQualAss::kSIM ; 
-  else if ( task == AliQualAss::kRECPOINTS ) 
-               index = AliQualAss::kREC ; 
-  else if ( task == AliQualAss::kTRACKSEGMENTS ) 
-               index = AliQualAss::kREC ; 
-  else if ( task == AliQualAss::kRECPARTICLES ) 
-               index = AliQualAss::kREC ; 
-  else if ( task == AliQualAss::kESDS ) 
-               index = AliQualAss::kESD ; 
+  AliQA::ALITASK 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 ; 
 
   qac->Init(det) ; 
-  qac->SetRefandData(GetRefSubDir(AliQualAss::GetDetName(det).Data(), AliQualAss::GetTaskName(task).Data())) ; 
+  qac->SetRefandData(GetRefSubDir(AliQA::GetDetName(det).Data(), AliQA::GetTaskName(task).Data())) ; 
   qac->Run(index, list) ; 
   
   return kTRUE ; 
@@ -308,7 +308,7 @@ Bool_t AliQualAssChecker::Run(AliQualAss::DETECTORINDEX det, AliQualAss::TASKIND
 }
 
 //_____________________________________________________________________________
-void AliQualAssChecker::SetQAResultDirName(const char * name)
+void AliQAChecker::SetQAResultDirName(const char * name)
 {
   // Set the root directory where to store the QA status object
 
@@ -320,7 +320,7 @@ void AliQualAssChecker::SetQAResultDirName(const char * name)
 }
 
 //_____________________________________________________________________________
-void AliQualAssChecker::SetRefDirName(const char * name)
+void AliQAChecker::SetRefDirName(const char * name)
 {
   // Set the root directory of reference data
 
similarity index 64%
rename from STEER/AliQualAssChecker.h
rename to STEER/AliQAChecker.h
index b27cf81..9356a32 100644 (file)
@@ -1,5 +1,5 @@
-#ifndef ALIQUALASSChecker_H
-#define ALIQUALASSChecker_H
+#ifndef ALIQAChecker_H
+#define ALIQAChecker_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
@@ -8,7 +8,7 @@
 //
 // class for running the Quality Assurance Checker
 // to run type:
-//   AliQualAssChecker qac;
+//   AliQAChecker qac;
 //   qac.Run();
 //   qac.SelectDetectors("list of detectors") ; 
 //   qac.SelectTargets("list of targets among Hits, Digits, ESD") ; 
 #include <TNamed.h>
 #include <TFile.h>  
 
-#include "AliQualAss.h"
-class AliQualAssCheckerBase ; 
+#include "AliQA.h"
+class AliQACheckerBase ; 
 
-class AliQualAssChecker: public TNamed {
+class AliQAChecker: public TNamed {
 public:
-  AliQualAssChecker(const char* name = "AliQualAssChecker", 
+  AliQAChecker(const char* name = "AliQAChecker", 
                    const char* title = "Quality Assurance checker for Raws, Hits, Digits and ESDs");
-  AliQualAssChecker(const AliQualAssChecker& qac);
-  AliQualAssChecker& operator = (const AliQualAssChecker& qac);
-  virtual ~AliQualAssChecker();
+  AliQAChecker(const AliQAChecker& qac);
+  AliQAChecker& operator = (const AliQAChecker& qac);
+  virtual ~AliQAChecker();
 
-  static  AliQualAssChecker * Instance() ;
-  AliQualAssCheckerBase *     GetDetQualAssChecker(Int_t det) ; 
+  static  AliQAChecker * Instance() ;
+  AliQACheckerBase *     GetDetQAChecker(Int_t det) ; 
   TDirectory *                GetRefSubDir(const char * det, const char * task) ;
   static TFile *              GetQAResultFile() ;
   static const char *         GetQAResultFileName() { return fgQAResultFileName.Data() ; }
@@ -37,12 +37,12 @@ public:
   void                        SetRefDirName(const char * name) ; 
 
   virtual Bool_t Run();
-  virtual Bool_t Run(AliQualAss::DETECTORINDEX det, AliQualAss::TASKINDEX task, TList * list);
+  virtual Bool_t Run(AliQA::DETECTORINDEX det, AliQA::TASKINDEX task, TList * list);
 
 private:
   TFile *      GetDataFile() ; 
 
-  static AliQualAssChecker *fgQAChecker ; // pointer to the instance of the singleton
+  static AliQAChecker *fgQAChecker ; // pointer to the instance of the singleton
   TFile * fDataFile ;                     //! Data file to check
   static TFile * fgQAResultFile ;         //! File where to find the QA result
   static TString fgQAResultDirName ;      //! directory where to find the QA result
@@ -50,7 +50,7 @@ private:
   TString fRefDirName ;                   //! name of directory where to find the reference data file
   TString fRefName ;                      //! file name where to find the reference data
   TString fFoundDetectors ;               //! detectors for which the Quality assurance could be done
-  AliQualAssCheckerBase * fCheckers[AliQualAss::kNDET] ; //! list of detectors checkers
-  ClassDef(AliQualAssChecker, 1)  // class for running generation, simulation and digitization
+  AliQACheckerBase * fCheckers[AliQA::kNDET] ; //! list of detectors checkers
+  ClassDef(AliQAChecker, 1)  // class for running generation, simulation and digitization
 };
 #endif
similarity index 76%
rename from STEER/AliQualAssCheckerBase.cxx
rename to STEER/AliQACheckerBase.cxx
index 593c2d8..4812889 100644 (file)
@@ -18,7 +18,7 @@
 
 /*
   Base class for detectors quality assurance checkers 
-  Compares Data made by QualAssDataMakers with reference data
+  Compares Data made by QADataMakers with reference data
   Y. Schutz CERN August 2007
 */
 
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQualAss.h"
-#include "AliQualAssChecker.h"
-#include "AliQualAssCheckerBase.h"
-#include "AliQualAssDataMaker.h"
+#include "AliQA.h"
+#include "AliQAChecker.h"
+#include "AliQACheckerBase.h"
+#include "AliQADataMaker.h"
 
-ClassImp(AliQualAssCheckerBase)
+ClassImp(AliQACheckerBase)
 
            
 //____________________________________________________________________________ 
-AliQualAssCheckerBase::AliQualAssCheckerBase(const char * name, const char * title) : 
+AliQACheckerBase::AliQACheckerBase(const char * name, const char * title) : 
   TNamed(name, title), 
   fDataSubDir(0x0),
   fRefSubDir(0x0) 
@@ -53,7 +53,7 @@ AliQualAssCheckerBase::AliQualAssCheckerBase(const char * name, const char * tit
 }
 
 //____________________________________________________________________________ 
-AliQualAssCheckerBase::AliQualAssCheckerBase(const AliQualAssCheckerBase& qadm) :
+AliQACheckerBase::AliQACheckerBase(const AliQACheckerBase& qadm) :
   TNamed(qadm.GetName(), qadm.GetTitle()),
   fDataSubDir(qadm.fDataSubDir), 
   fRefSubDir(qadm.fRefSubDir)
@@ -63,16 +63,16 @@ AliQualAssCheckerBase::AliQualAssCheckerBase(const AliQualAssCheckerBase& qadm)
 }
 
 //____________________________________________________________________________
-AliQualAssCheckerBase& AliQualAssCheckerBase::operator = (const AliQualAssCheckerBase& qadm )
+AliQACheckerBase& AliQACheckerBase::operator = (const AliQACheckerBase& qadm )
 {
   // Equal operator.
-  this->~AliQualAssCheckerBase();
-  new(this) AliQualAssCheckerBase(qadm);
+  this->~AliQACheckerBase();
+  new(this) AliQACheckerBase(qadm);
   return *this;
 }
 
 //____________________________________________________________________________
-const Double_t AliQualAssCheckerBase::Check() 
+const Double_t AliQACheckerBase::Check() 
 {
   // Performs a basic checking
   // Compares all the histograms stored in the directory
@@ -116,7 +116,7 @@ const Double_t AliQualAssCheckerBase::Check()
 }  
 
 //____________________________________________________________________________
-const Double_t AliQualAssCheckerBase::Check(TList * list) 
+const Double_t AliQACheckerBase::Check(TList * list) 
 {
   // Performs a basic checking
   // Compares all the histograms in the list
@@ -156,11 +156,11 @@ const Double_t AliQualAssCheckerBase::Check(TList * list)
 }  
 
 //____________________________________________________________________________ 
-const Double_t AliQualAssCheckerBase::DiffC(const TH1 * href, const TH1 * hin) const
+const Double_t AliQACheckerBase::DiffC(const TH1 * href, const TH1 * hin) const
 {
   // compares two histograms using the Chi2 test
   if ( hin->Integral() == 0 ) {
-    AliWarning(Form("Spectrum %s in %s is empty", hin->GetName(), AliQualAss::GetDataName())) ; 
+    AliWarning(Form("Spectrum %s in %s is empty", hin->GetName(), AliQA::GetDataName())) ; 
     return 0. ;
   }
     
@@ -168,11 +168,11 @@ const Double_t AliQualAssCheckerBase::DiffC(const TH1 * href, const TH1 * hin) c
 }
 
 //____________________________________________________________________________ 
-const Double_t AliQualAssCheckerBase::DiffK(const TH1 * href, const TH1 * hin) const
+const Double_t AliQACheckerBase::DiffK(const TH1 * href, const TH1 * hin) const
 {
   // compares two histograms using the Kolmogorov test
   if ( hin->Integral() == 0 ) {
-    AliWarning(Form("Spectrum %s in %s is empty", hin->GetName(), AliQualAss::GetDataName())) ; 
+    AliWarning(Form("Spectrum %s in %s is empty", hin->GetName(), AliQA::GetDataName())) ; 
     return 0. ;
   }
     
@@ -180,17 +180,17 @@ const Double_t AliQualAssCheckerBase::DiffK(const TH1 * href, const TH1 * hin) c
 }
 
 //____________________________________________________________________________ 
-void AliQualAssCheckerBase::Init(const AliQualAss::DETECTORINDEX det)
+void AliQACheckerBase::Init(const AliQA::DETECTORINDEX det)
 {
-  AliQualAss::Instance(det) ; 
+  AliQA::Instance(det) ; 
 }
  
 //____________________________________________________________________________
-void AliQualAssCheckerBase::Run(AliQualAss::ALITASK index, TList * list) 
+void AliQACheckerBase::Run(AliQA::ALITASK index, TList * list) 
 { 
-  AliInfo(Form("Processing %s", AliQualAss::GetAliTaskName(index))) ; 
+  AliInfo(Form("Processing %s", AliQA::GetAliTaskName(index))) ; 
 
-  AliQualAss * qa = AliQualAss::Instance(index) ; 
+  AliQA * qa = AliQA::Instance(index) ; 
 
   Double_t rv = -1 ;   
   if (list)
@@ -199,25 +199,25 @@ void AliQualAssCheckerBase::Run(AliQualAss::ALITASK index, TList * list)
     rv = Check() ;   
 
   if ( rv <= 0.) 
-    qa->Set(AliQualAss::kFATAL) ; 
+    qa->Set(AliQA::kFATAL) ; 
   else if ( rv > 0 && rv <= 0.2 )
-    qa->Set(AliQualAss::kERROR) ; 
+    qa->Set(AliQA::kERROR) ; 
   else if ( rv > 0.2 && rv <= 0.5 )
-    qa->Set(AliQualAss::kWARNING) ;
+    qa->Set(AliQA::kWARNING) ;
   else if ( rv > 0.5 && rv < 1 ) 
-    qa->Set(AliQualAss::kINFO) ; 
-  AliInfo(Form("Test result of %s", AliQualAss::GetAliTaskName(index))) ;
+    qa->Set(AliQA::kINFO) ; 
+  AliInfo(Form("Test result of %s", AliQA::GetAliTaskName(index))) ;
   Finish() ; 
 }
 
 //____________________________________________________________________________
-void AliQualAssCheckerBase::Finish() const 
+void AliQACheckerBase::Finish() const 
 {
   // wrap up and save QA in proper file
     
-  AliQualAss * qa = AliQualAss::Instance() ; 
+  AliQA * qa = AliQA::Instance() ; 
   qa->Show() ;
-  AliQualAssChecker::GetQAResultFile()->cd() ; 
+  AliQAChecker::GetQAResultFile()->cd() ; 
   qa->Write(qa->GetName(), kWriteDelete) ;   
-  AliQualAssChecker::GetQAResultFile()->Close() ;  
+  AliQAChecker::GetQAResultFile()->Close() ;  
 }
similarity index 61%
rename from STEER/AliQualAssCheckerBase.h
rename to STEER/AliQACheckerBase.h
index 56b5cfa..58e50ed 100644 (file)
@@ -1,5 +1,5 @@
-#ifndef ALIQUALASSCHECKERBASE_H
-#define ALIQUALASSCHECKERBASE_H
+#ifndef ALIQACHECKERBASE_H
+#define ALIQACHECKERBASE_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
@@ -8,14 +8,14 @@
 
 /*
   Base class for detectors quality assurance checkers 
-  Compares Data made by QualAssDataMakers with reference data
+  Compares Data made by QADataMakers with reference data
   Y. Schutz CERN August 2007
 */
 
 
 // --- ROOT system ---
 #include <TNamed.h>
-#include "AliQualAss.h"
+#include "AliQA.h"
 class TFile ; 
 class TH1 ; 
 class TList ; 
@@ -24,17 +24,16 @@ class TList ;
 
 // --- AliRoot header files ---
 
-class AliQualAssCheckerBase: public TNamed {
+class AliQACheckerBase: public TNamed {
 
 public:
-  AliQualAssCheckerBase(const char * name = "", const char * title = "") ;          // ctor
-  AliQualAssCheckerBase(const AliQualAssCheckerBase& qac) ;   
-  AliQualAssCheckerBase& operator = (const AliQualAssCheckerBase& qac) ;
-  virtual ~AliQualAssCheckerBase() {;} // dtor
-
-  void   Init(const AliQualAss::DETECTORINDEX det) ; 
-  void   Run(AliQualAss::ALITASK tsk); 
-  void   Run(AliQualAss::ALITASK tsk, TList * list); 
+  AliQACheckerBase(const char * name = "", const char * title = "") ;          // ctor
+  AliQACheckerBase(const AliQACheckerBase& qac) ;   
+  AliQACheckerBase& operator = (const AliQACheckerBase& qac) ;
+  virtual ~AliQACheckerBase() {;} // dtor
+
+  void   Init(const AliQA::DETECTORINDEX det) ; 
+  void   Run(AliQA::ALITASK tsk, TList * list=0x0); 
   void   SetRefandData(TDirectory * ref, TDirectory * data=NULL) { fRefSubDir = ref ;  fDataSubDir = data ; }
 
 protected:
@@ -47,7 +46,7 @@ protected:
   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
 
-  ClassDef(AliQualAssCheckerBase,1)  // description 
+  ClassDef(AliQACheckerBase,1)  // description 
 
 };
 
similarity index 76%
rename from STEER/AliQualAssDataMaker.cxx
rename to STEER/AliQADataMaker.cxx
index dfd1adf..6546a0f 100644 (file)
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQualAssDataMaker.h"
-#include "AliQualAssChecker.h"
+#include "AliQADataMaker.h"
+#include "AliQAChecker.h"
 #include "AliESDEvent.h"
 #include "AliRawReader.h"
 
-ClassImp(AliQualAssDataMaker)
+ClassImp(AliQADataMaker)
   
-TString AliQualAssDataMaker::fDetectorDirName("") ;
+TString AliQADataMaker::fDetectorDirName("") ;
 
            
 //____________________________________________________________________________ 
-AliQualAssDataMaker::AliQualAssDataMaker(const char * name, const char * title) : 
+AliQADataMaker::AliQADataMaker(const char * name, const char * title) : 
   TNamed(name, title), 
   fOutput(0x0),
   fDetectorDir(0x0),
@@ -65,7 +65,7 @@ AliQualAssDataMaker::AliQualAssDataMaker(const char * name, const char * title)
 }
 
 //____________________________________________________________________________ 
-AliQualAssDataMaker::AliQualAssDataMaker(const AliQualAssDataMaker& qadm) :
+AliQADataMaker::AliQADataMaker(const AliQADataMaker& qadm) :
   TNamed(qadm.GetName(), qadm.GetTitle()),
   fOutput(qadm.fOutput),
   fDetectorDir(qadm.fDetectorDir),
@@ -85,22 +85,22 @@ AliQualAssDataMaker::AliQualAssDataMaker(const AliQualAssDataMaker& qadm) :
 }
 
 //____________________________________________________________________________ 
-AliQualAssDataMaker::~AliQualAssDataMaker() 
+AliQADataMaker::~AliQADataMaker() 
 {
 // dtor
 } 
 
 //__________________________________________________________________
-AliQualAssDataMaker& AliQualAssDataMaker::operator = (const AliQualAssDataMaker& qadm )
+AliQADataMaker& AliQADataMaker::operator = (const AliQADataMaker& qadm )
 {
   // Equal operator.
-  this->~AliQualAssDataMaker();
-  new(this) AliQualAssDataMaker(qadm);
+  this->~AliQADataMaker();
+  new(this) AliQADataMaker(qadm);
   return *this;
 }
 
 //____________________________________________________________________________
-void AliQualAssDataMaker::EndOfCycle(AliQualAss::TASKINDEX task) 
+void AliQADataMaker::EndOfCycle(AliQA::TASKINDEX task) 
 { 
   // Finishes a cycle of QA data acquistion
   
@@ -108,51 +108,51 @@ void AliQualAssDataMaker::EndOfCycle(AliQualAss::TASKINDEX task)
   
  switch (task) { 
   
-  case AliQualAss::kRAWS:    
+  case AliQA::kRAWS:    
        list = fRawsQAList ; 
   break ; 
 
-  case AliQualAss::kHITS:
+  case AliQA::kHITS:
        list = fHitsQAList ; 
   break ; 
 
-  case AliQualAss::kSDIGITS:
+  case AliQA::kSDIGITS:
        list = fSDigitsQAList ; 
   break ; 
     
-  case AliQualAss::kDIGITS:
+  case AliQA::kDIGITS:
        list = fDigitsQAList ; 
   break ;  
  
-   case AliQualAss::kRECPOINTS:
+   case AliQA::kRECPOINTS:
        list = fRecPointsQAList ; 
    break ;  
 
-   case AliQualAss::kTRACKSEGMENTS:
+   case AliQA::kTRACKSEGMENTS:
    break ;  
   
-   case AliQualAss::kRECPARTICLES:
+   case AliQA::kRECPARTICLES:
    break ;  
     
-   case AliQualAss::kESDS:
+   case AliQA::kESDS:
        list = fESDsQAList ; 
    break ;  
   }    
   
  EndOfDetectorCycle(task, list) ; 
- TDirectory * subDir = fDetectorDir->GetDirectory(AliQualAss::GetTaskName(task)) ; 
+ TDirectory * subDir = fDetectorDir->GetDirectory(AliQA::GetTaskName(task)) ; 
  subDir->cd() ; 
  list->Write() ; 
 }
  
 //____________________________________________________________________________
-void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task, TObject * data) 
+void AliQADataMaker::Exec(AliQA::TASKINDEX task, TObject * data) 
 { 
   // creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs)
     
   switch (task) { 
   
-  case AliQualAss::kRAWS:
+  case AliQA::kRAWS:
   {
     AliInfo("Processing Raws QA") ; 
        AliRawReader * rawReader = dynamic_cast<AliRawReader *>(data) ; 
@@ -162,7 +162,7 @@ void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task, TObject * data)
          AliError("Wrong data type") ;     
     break ; 
   }
-  case AliQualAss::kHITS:
+  case AliQA::kHITS:
   {  
        AliInfo("Processing Hits QA") ; 
        TClonesArray * hits = dynamic_cast<TClonesArray *>(data) ; 
@@ -172,7 +172,7 @@ void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task, TObject * data)
      AliError("Wrong type of hits container") ;
     break ; 
   }
-  case AliQualAss::kSDIGITS:
+  case AliQA::kSDIGITS:
   {
     AliInfo("Processing SDigits QA") ; 
     TClonesArray * sdigits = dynamic_cast<TClonesArray *>(data) ; 
@@ -182,7 +182,7 @@ void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task, TObject * data)
       AliError("Wrong type of sdigits container") ; 
     break ; 
   }  
-  case AliQualAss::kDIGITS:
+  case AliQA::kDIGITS:
   {
     TClonesArray * digits = dynamic_cast<TClonesArray *>(data) ; 
     if (digits) 
@@ -191,7 +191,7 @@ void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task, TObject * data)
       AliError("Wrong type of digits container") ; 
     break ;  
   }
-  case AliQualAss::kRECPOINTS:
+  case AliQA::kRECPOINTS:
   {
      AliInfo("Processing RecPoints QA") ; 
      TTree * recpoints = dynamic_cast<TTree *>(data) ; 
@@ -201,7 +201,7 @@ void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task, TObject * data)
       AliError("Wrong type of recpoints container") ; 
     break ;  
   }
-   case AliQualAss::kTRACKSEGMENTS:
+   case AliQA::kTRACKSEGMENTS:
     AliInfo("Processing Track Segments QA: not existing anymore") ; 
 //     TTree * ts = dynamic_cast<TTree *>(data) ; 
 //     if (ts) 
@@ -210,7 +210,7 @@ void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task, TObject * data)
 //       AliError("Wrong type of track segments container") ; 
     break ;  
   
-    case AliQualAss::kRECPARTICLES:
+    case AliQA::kRECPARTICLES:
     AliInfo("Processing RecParticles QA: not existing anymore") ; 
 //     TTree * recpar = dynamic_cast<TTree *>(data) ; 
 //     if (recpar) 
@@ -219,7 +219,7 @@ void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task, TObject * data)
 //       AliError("Wrong type of recparticles container") ; 
     break ;  
     
-  case AliQualAss::kESDS:
+  case AliQA::kESDS:
    {
     AliInfo("Processing ESDs QA") ; 
     AliESDEvent * esd = dynamic_cast<AliESDEvent *>(data) ; 
@@ -233,14 +233,14 @@ void AliQualAssDataMaker::Exec(AliQualAss::TASKINDEX task, TObject * data)
 }
 
 //____________________________________________________________________________ 
-void AliQualAssDataMaker::Finish(AliQualAss::TASKINDEX) const 
+void AliQADataMaker::Finish(AliQA::TASKINDEX) const 
 { 
   // write to the output File
   fOutput->Close() ; 
 } 
 
 //____________________________________________________________________________ 
-TList *  AliQualAssDataMaker::Init(AliQualAss::TASKINDEX task, Int_t run, Int_t cycles)
+TList *  AliQADataMaker::Init(AliQA::TASKINDEX task, Int_t run, Int_t cycles)
 {
   // general intialisation
   
@@ -249,50 +249,50 @@ TList *  AliQualAssDataMaker::Init(AliQualAss::TASKINDEX task, Int_t run, Int_t
     SetCycle(cycles) ;  
        
   switch (task) {
-  case AliQualAss::kRAWS: 
+  case AliQA::kRAWS: 
    {
        fRawsQAList = new TList() ;      
     InitRaws() ;
        return fRawsQAList ;
     break ; 
    }
-  case AliQualAss::kHITS: 
+  case AliQA::kHITS: 
    {
        fHitsQAList = new TList() ;      
     InitHits() ;
        return fHitsQAList ;
     break ; 
    }
-  case AliQualAss::kSDIGITS: 
+  case AliQA::kSDIGITS: 
    {
        fSDigitsQAList = new TList() ; 
     InitSDigits() ;
        return fSDigitsQAList ;
     break ; 
    }
-  case AliQualAss::kDIGITS: 
+  case AliQA::kDIGITS: 
    {
        fDigitsQAList = new TList(); 
        InitDigits() ;
        return fDigitsQAList ;
        break ; 
    }     
-  case AliQualAss::kRECPOINTS: 
+  case AliQA::kRECPOINTS: 
    {
        fRecPointsQAList = new TList ; 
     InitRecPoints() ;
        return fRecPointsQAList ;
     break ; 
   }
-  case AliQualAss::kTRACKSEGMENTS: 
+  case AliQA::kTRACKSEGMENTS: 
 //  InitTrackSegments() ;
     break ; 
     
-  case AliQualAss::kRECPARTICLES: 
+  case AliQA::kRECPARTICLES: 
 //    InitRecParticles() ;
     break ; 
     
-  case AliQualAss::kESDS: 
+  case AliQA::kESDS: 
    {
        fESDsQAList = new TList() ; 
        InitESDs() ;
@@ -304,7 +304,7 @@ TList *  AliQualAssDataMaker::Init(AliQualAss::TASKINDEX task, Int_t run, Int_t
 }
 
 //____________________________________________________________________________
-void AliQualAssDataMaker::StartOfCycle(AliQualAss::TASKINDEX task, Option_t * sameCycle) 
+void AliQADataMaker::StartOfCycle(AliQA::TASKINDEX task, Option_t * sameCycle) 
 { 
   // Finishes a cycle of QA data acquistion
  
@@ -312,51 +312,51 @@ void AliQualAssDataMaker::StartOfCycle(AliQualAss::TASKINDEX task, Option_t * sa
    ResetCycle() ;
    if (fOutput) 
        fOutput->Close() ; 
-   fOutput = AliQualAss::GetQADMOutFile(GetName(), fRun, fCurrentCycle) ;      
+   fOutput = AliQA::GetQADMOutFile(GetName(), fRun, fCurrentCycle) ;   
  }
        
  AliInfo(Form(" Run %d Cycle %d task %s file %s", 
-       fRun, fCurrentCycle, AliQualAss::GetTaskName(task).Data(), fOutput->GetName() )) ;
+       fRun, fCurrentCycle, AliQA::GetTaskName(task).Data(), fOutput->GetName() )) ;
 
  fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ; 
  if (!fDetectorDir)
    fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ; 
 
- TDirectory * subDir = fDetectorDir->GetDirectory(AliQualAss::GetTaskName(task)) ; 
+ TDirectory * subDir = fDetectorDir->GetDirectory(AliQA::GetTaskName(task)) ; 
  if (!subDir)
-   subDir = fDetectorDir->mkdir(AliQualAss::GetTaskName(task)) ;  
+   subDir = fDetectorDir->mkdir(AliQA::GetTaskName(task)) ;  
  subDir->cd() ; 
 
   TList * list = 0x0 ; 
   
   switch (task) { 
-  case AliQualAss::kRAWS: 
+  case AliQA::kRAWS: 
        list = fRawsQAList ; 
     break ; 
 
-  case AliQualAss::kHITS: 
+  case AliQA::kHITS: 
        list = fHitsQAList ; 
     break ; 
   
-  case AliQualAss::kSDIGITS: 
+  case AliQA::kSDIGITS: 
        list = fSDigitsQAList ;
     break ; 
 
-  case AliQualAss::kDIGITS: 
+  case AliQA::kDIGITS: 
        list = fDigitsQAList ;
        break ; 
          
-  case AliQualAss::kRECPOINTS: 
+  case AliQA::kRECPOINTS: 
        list = fRecPointsQAList ;
        break ; 
 
-  case AliQualAss::kTRACKSEGMENTS: 
+  case AliQA::kTRACKSEGMENTS: 
     break ; 
     
-  case AliQualAss::kRECPARTICLES: 
+  case AliQA::kRECPARTICLES: 
     break ; 
     
-  case AliQualAss::kESDS: 
+  case AliQA::kESDS: 
        list = fESDsQAList ;
     break ; 
   }  
similarity index 84%
rename from STEER/AliQualAssDataMaker.h
rename to STEER/AliQADataMaker.h
index 3377e7d..6bb37c6 100644 (file)
@@ -1,5 +1,5 @@
-#ifndef ALIQUALASSDATAMAKER_H
-#define ALIQUALASSDATAMAKER_H
+#ifndef ALIQADATAMAKER_H
+#define ALIQADATAMAKER_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
@@ -29,23 +29,23 @@ class TClonesArray;
 // --- Standard library ---
 
 // --- AliRoot header files ---
-#include "AliQualAss.h"
+#include "AliQA.h"
 
-class AliQualAssDataMaker: public TNamed {
+class AliQADataMaker: public TNamed {
   
 public:
   
-  AliQualAssDataMaker(const char * name="", const char * title="") ;          // ctor
-  AliQualAssDataMaker(const AliQualAssDataMaker& qadm) ;   
-  AliQualAssDataMaker& operator = (const AliQualAssDataMaker& qadm) ;
-  virtual ~AliQualAssDataMaker() ; // dtor
+  AliQADataMaker(const char * name="", const char * title="") ;          // ctor
+  AliQADataMaker(const AliQADataMaker& qadm) ;   
+  AliQADataMaker& operator = (const AliQADataMaker& qadm) ;
+  virtual ~AliQADataMaker() ; // dtor
   
-  virtual void        Exec(AliQualAss::TASKINDEX, TObject * data) ;
-  void                EndOfCycle(AliQualAss::TASKINDEX) ;
-  void                Finish(AliQualAss::TASKINDEX task) const ; 
+  virtual void        Exec(AliQA::TASKINDEX, TObject * data) ;
+  void                EndOfCycle(AliQA::TASKINDEX) ;
+  void                Finish(AliQA::TASKINDEX task) const ; 
   static const char * GetDetectorDirName() { return fDetectorDirName.Data() ; }
   const Int_t         Increment() { return ++fCycleCounter ; } 
-  TList *             Init(AliQualAss::TASKINDEX, Int_t run, Int_t cycles = -1) ;
+  TList *             Init(AliQA::TASKINDEX, Int_t run, Int_t cycles = -1) ;
   const Bool_t        IsCycleDone() const { return fCycleCounter > fCycle ? kTRUE : kFALSE ; }
   const Int_t         Add2DigitsList(TH1 * hist, const Int_t index)    { return Add2List(hist, index, fDigitsQAList) ; }
   const Int_t         Add2ESDsList(TH1 * hist, const Int_t index)      { return Add2List(hist, index, fESDsQAList) ; }
@@ -60,12 +60,12 @@ public:
   TH1 *               GetRawsData(const Int_t index)      { return dynamic_cast<TH1 *>(GetData(fRawsQAList, index)) ; }
   TH1 *               GetSDigitsData(const Int_t index)   { return dynamic_cast<TH1 *>(GetData(fSDigitsQAList, index)) ; }
   void                SetCycle(Int_t nevts) { fCycle = nevts ; } 
-  void                StartOfCycle(AliQualAss::TASKINDEX, Option_t * sameCycle = "new") ;
+  void                StartOfCycle(AliQA::TASKINDEX, Option_t * sameCycle = "new") ;
 
 protected: 
 
   Int_t          Add2List(TH1 * hist, const Int_t index, TList * list) { list->AddAt(hist, index) ; return list->LastIndex() ; }
-  virtual void   EndOfDetectorCycle(AliQualAss::TASKINDEX, TList * ) {AliInfo("To be implemented by detectors");} 
+  virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TList * ) {AliInfo("To be implemented by detectors");} 
   TObject *      GetData(TList * list, const Int_t index)  { return list->At(index) ; } 
   virtual void   InitDigits()        {AliInfo("To be implemented by detectors");}
   virtual void   InitESDs()          {AliInfo("To be implemented by detectors");}
@@ -100,8 +100,8 @@ protected:
   Int_t          fCycleCounter ;    //! cycle counter
   Int_t          fRun ;             //! run number
   
- ClassDef(AliQualAssDataMaker,1)  // description 
+ ClassDef(AliQADataMaker,1)  // description 
 
 };
 
-#endif // AliQualAssDataMaker_H
+#endif // AliQADataMaker_H
index 3c0a0aa..7249cd8 100644 (file)
 #include "AliAODVertex.h"
 #include "AliAODCluster.h"
 
-#include "AliQualAssDataMaker.h" 
+#include "AliQADataMaker.h" 
 
 //#include "TMemStatManager.h" // memory snapshots
 #include "AliSysInfo.h" // memory snapshots
@@ -235,7 +235,7 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, const char* cdb
     fReconstructor[iDet] = NULL;
     fLoader[iDet] = NULL;
     fTracker[iDet] = NULL;
-    fQualAssDataMaker[iDet] = NULL;
+    fQADataMaker[iDet] = NULL;
        fQACycles[iDet] = 999999;       
   }
   AliPID pid;
@@ -297,7 +297,7 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
     fReconstructor[iDet] = NULL;
     fLoader[iDet] = NULL;
     fTracker[iDet] = NULL;
-    fQualAssDataMaker[iDet] = NULL;
+    fQADataMaker[iDet] = NULL;
        fQACycles[iDet] = rec.fQACycles[iDet];  
   }
   for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
@@ -786,7 +786,7 @@ Bool_t AliReconstruction::Run(const char* input)
     }
   
     if (!fFillESD.IsNull()) 
-    RunQualAss(fFillESD.Data(), esd);
+    RunQA(fFillESD.Data(), esd);
 
     // fill Event header information from the RawEventHeader
     if (fRawReader){FillRawEventHeaderESD(esd);}
@@ -876,14 +876,12 @@ Bool_t AliReconstruction::Run(const char* input)
   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
        if (!IsSelected(fgkDetectorName[iDet], detStr)) 
                continue;
-    AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
+    AliQADataMaker * qadm = GetQADataMaker(iDet);
     if (!qadm) continue;
-    
-    qadm->EndOfCycle(AliQualAss::kRECPOINTS);
-    qadm->EndOfCycle(AliQualAss::kESDS);
-    qadm->Finish(AliQualAss::kRECPOINTS);
-    qadm->Finish(AliQualAss::kESDS) ; 
-    
+    qadm->EndOfCycle(AliQA::kRECPOINTS);
+    qadm->EndOfCycle(AliQA::kESDS);
+    qadm->Finish(AliQA::kRECPOINTS);
+    qadm->Finish(AliQA::kESDS) ; 
   }
 
   tree->GetUserInfo()->Add(esd);
@@ -1037,19 +1035,18 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
       loader->UnloadDigits();
     }
 
-    AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
+    AliQADataMaker * qadm = GetQADataMaker(iDet);
     if (qadm) {
       AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
       AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
          
-      if (qadm->IsCycleDone() ) {
-       
-       qadm->EndOfCycle(AliQualAss::kRECPOINTS) ; 
-       qadm->EndOfCycle(AliQualAss::kESDS) ; 
-      qadm->StartOfCycle(AliQualAss::kRECPOINTS) ; 
-      qadm->StartOfCycle(AliQualAss::kESDS, "same") ; 
-   }
-      qadm->Exec(AliQualAss::kRECPOINTS, clustersTree) ; 
+     if (qadm->IsCycleDone() ) {
+      qadm->EndOfCycle(AliQA::kRECPOINTS) ; 
+         qadm->EndOfCycle(AliQA::kESDS) ; 
+      qadm->StartOfCycle(AliQA::kRECPOINTS) ; 
+         qadm->StartOfCycle(AliQA::kESDS, "same") ; 
+     }
+      qadm->Exec(AliQA::kRECPOINTS, clustersTree) ; 
       AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
     }
 
@@ -1777,8 +1774,8 @@ void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
     fLoader[iDet] = NULL;
     delete fTracker[iDet];
     fTracker[iDet] = NULL;
-    delete fQualAssDataMaker[iDet];
-    fQualAssDataMaker[iDet] = NULL;
+    delete fQADataMaker[iDet];
+    fQADataMaker[iDet] = NULL;
   }
   delete fVertexer;
   fVertexer = NULL;
@@ -2694,54 +2691,54 @@ void AliReconstruction::TNamedToFile(TTree* fTree, TString fName){
 }
 
 //_____________________________________________________________________________
-AliQualAssDataMaker * AliReconstruction::GetQualAssDataMaker(Int_t iDet)
+AliQADataMaker * AliReconstruction::GetQADataMaker(Int_t iDet)
 {
 // get the quality assurance data maker object and the loader for a detector
 
-  if (fQualAssDataMaker[iDet]) 
-    return fQualAssDataMaker[iDet];
+  if (fQADataMaker[iDet]) 
+    return fQADataMaker[iDet];
 
   // load the QA data maker object
   TPluginManager* pluginManager = gROOT->GetPluginManager();
   TString detName = fgkDetectorName[iDet];
-  TString qadmName = "Ali" + detName + "QualAssDataMaker";
+  TString qadmName = "Ali" + detName + "QADataMaker";
   if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) 
     return NULL;
 
-  AliQualAssDataMaker * qadm = NULL;
+  AliQADataMaker * qadm = NULL;
   // first check if a plugin is defined for the quality assurance data maker
-  TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQualAssDataMaker", detName);
+  TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName);
   // if not, add a plugin for it
   if (!pluginHandler) {
     AliDebug(1, Form("defining plugin for %s", qadmName.Data()));
     TString libs = gSystem->GetLibraries();
     if (libs.Contains("lib" + detName + "base.so") ||
        (gSystem->Load("lib" + detName + "base.so") >= 0)) {
-      pluginManager->AddHandler("AliQualAssDataMaker", detName, 
+      pluginManager->AddHandler("AliQADataMaker", detName, 
                                qadmName, detName + "qadm", qadmName + "()");
     } else {
-      pluginManager->AddHandler("AliQualAssDataMaker", detName, 
+      pluginManager->AddHandler("AliQADataMaker", detName, 
                                qadmName, detName, qadmName + "()");
     }
-    pluginHandler = pluginManager->FindHandler("AliQualAssDataMaker", detName);
+    pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName);
   }
   if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
-    qadm = (AliQualAssDataMaker *) pluginHandler->ExecPlugin(0);
+    qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0);
   }
   if (qadm) {
     AliInfo(Form("Initializing quality assurance data maker for %s", fgkDetectorName[iDet]));
-    qadm->Init(AliQualAss::kRECPOINTS, fRunLoader->GetHeader()->GetRun(), GetQACycles(fgkDetectorName[iDet]));
-    qadm->Init(AliQualAss::kESDS, fRunLoader->GetHeader()->GetRun(), GetQACycles(fgkDetectorName[iDet]));
-    qadm->StartOfCycle(AliQualAss::kRECPOINTS);
-        qadm->StartOfCycle(AliQualAss::kESDS, "same") ;        
-    fQualAssDataMaker[iDet] = qadm;
+    qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), GetQACycles(fgkDetectorName[iDet]));
+    qadm->StartOfCycle(AliQA::kRECPOINTS);
+    qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
+    qadm->StartOfCycle(AliQA::kESDS, "same") ;         
+    fQADataMaker[iDet] = qadm;
   }
 
   return qadm;
 }
 
 //_____________________________________________________________________________
-Bool_t AliReconstruction::RunQualAss(const char* detectors, AliESDEvent *& esd)
+Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd)
 {
   // run the Quality Assurance data producer
 
@@ -2750,14 +2747,14 @@ Bool_t AliReconstruction::RunQualAss(const char* detectors, AliESDEvent *& esd)
   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
    if (!IsSelected(fgkDetectorName[iDet], detStr)) 
      continue;
-   AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
+   AliQADataMaker * qadm = GetQADataMaker(iDet);
    if (!qadm) 
      continue;
    AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
    AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
     
-      qadm->Exec(AliQualAss::kESDS, esd) ; 
-      qadm->Increment() ; 
+   qadm->Exec(AliQA::kESDS, esd) ; 
+   qadm->Increment() ; 
 
    AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
  }
index 2ae6730..d65d9e7 100644 (file)
@@ -31,7 +31,7 @@ class AliESDVertex;
 class AliESDEvent;
 class TFile;
 class TTree;
-class AliQualAssDataMaker;
+class AliQADataMaker;
 
 class AliReconstruction: public TNamed {
 public:
@@ -108,7 +108,7 @@ public:
   virtual Bool_t Run(const char* input = NULL);
 
   // Quality Assurance 
-  virtual Bool_t RunQualAss(const char* detectors, AliESDEvent *& esd);
+  virtual Bool_t RunQA(const char* detectors, AliESDEvent *& esd);
   void    SetQACycles(const char * detector, const Int_t cycles) { fQACycles[GetDetIndex(detector)] = cycles ; }
 
 private:
@@ -142,7 +142,7 @@ private:
 
   //Quality Assurance
   Int_t                GetDetIndex(const char * detector);
-  AliQualAssDataMaker* GetQualAssDataMaker(Int_t iDet);
+  AliQADataMaker*      GetQADataMaker(Int_t iDet);
   const Int_t          GetQACycles(const char * detector) { return fQACycles[GetDetIndex(detector)] ; }
 
   //*** Global reconstruction flags *******************
@@ -198,7 +198,7 @@ private:
   TObjArray      fSpecCDBUri;         // Array with detector specific CDB storages
 
   //Quality Assurance
-  AliQualAssDataMaker * fQualAssDataMaker[fgkNDetectors];  //! array of QA data maker objects
+  AliQADataMaker * fQADataMaker[fgkNDetectors];  //! array of QA data maker objects
   Int_t                 fQACycles[fgkNDetectors] ;         // cycle length (# events) over which QA data are accumulated
 
   ClassDef(AliReconstruction, 15)      // class for running the reconstruction
index aeadda6..2415f0d 100644 (file)
 #pragma link C++ class AliFstream+;
 #pragma link C++ class AliCTPRawData+;
 
-#pragma link C++ class AliQualAss+;
-#pragma link C++ class AliQualAssDataMaker+;
-#pragma link C++ class AliQualAssChecker+;
-#pragma link C++ class AliQualAssCheckerBase+;
+#pragma link C++ class AliQA+;
+#pragma link C++ class AliQADataMaker+;
+#pragma link C++ class AliQAChecker+;
+#pragma link C++ class AliQACheckerBase+;
 
 #endif
index cf8f0e8..e53683f 100644 (file)
@@ -45,10 +45,10 @@ AliSurveyObj.cxx AliSurveyPoint.cxx \
 AliCodeTimer.cxx \
 AliFstream.cxx \
 AliCTPRawData.cxx \
-AliQualAss.cxx \
-AliQualAssDataMaker.cxx \
-AliQualAssChecker.cxx \
-AliQualAssCheckerBase.cxx
+AliQA.cxx \
+AliQADataMaker.cxx \
+AliQAChecker.cxx \
+AliQACheckerBase.cxx