// 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 !
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() {}
// --- 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),
}
//____________________________________________________________________________
-AliQualAss::AliQualAss(const AliQualAss& qa) :
+AliQA::AliQA(const AliQA& qa) :
TNamed(qa),
fQA(qa.fQA),
fDet(qa.fDet),
}
//_____________________________________________________________________________
-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),
}
//_______________________________________________________________
-AliQualAss::AliQualAss(const ALITASK tsk) :
+AliQA::AliQA(const ALITASK tsk) :
TNamed("QA", "Quality Assurance status"),
fQA(new ULong_t[kNDET]),
fDet(kNULLDET),
}
//____________________________________________________________________________
-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
}
//_______________________________________________________________
-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 ;
}
//_______________________________________________________________
-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
//_______________________________________________________________
-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] ;
}
//_______________________________________________________________
-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)
}
//_______________________________________________________________
-const char * AliQualAss::GetAliTaskName(ALITASK tsk)
+const char * AliQA::GetAliTaskName(ALITASK tsk)
{
// returns the char name corresponding to module index
TString tskName ;
}
//_______________________________________________________________
-const Bool_t AliQualAss::CheckFatal() const
+const Bool_t AliQA::CheckFatal() const
{
// check if any FATAL status is set
Bool_t rv = kFALSE ;
}
//_______________________________________________________________
-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
}
//_______________________________________________________________
-AliQualAss * AliQualAss::Instance()
+AliQA * AliQA::Instance()
{
// Get an instance of the singleton.
// Object must have been instantiated with Instance(ALITASK) first
}
//_______________________________________________________________
-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.
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()") ;
}
//_______________________________________________________________
-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)
}
//_______________________________________________________________
-void AliQualAss::Set(QABIT bit)
+void AliQA::Set(QABIT bit)
{
// Set the status bit of the current detector in the current module
}
//_______________________________________________________________
-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
}
//_______________________________________________________________
-void AliQualAss::ShowAll() const
+void AliQA::ShowAll() const
{
// dispplay the QA status word
Int_t index ;
}
//_______________________________________________________________
-void AliQualAss::ShowStatus(DETECTORINDEX det) const
+void AliQA::ShowStatus(DETECTORINDEX det) const
{
// Prints the full QA status of a given detector
CheckRange(det) ;
-#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 */
#include "AliLog.h"
-class AliQualAss : public TNamed {
+class AliQA : public TNamed {
public:
enum DETECTORINDEX {
};
// 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() ; }
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)
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
#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/"),
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() ;
}
//_____________________________________________________________________________
-AliQualAssChecker::AliQualAssChecker(const AliQualAssChecker& qac) :
+AliQAChecker::AliQAChecker(const AliQAChecker& qac) :
TNamed(qac),
fDataFile(qac.fDataFile),
fRefDirName(qac.fRefDirName),
{
// 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
}
//_____________________________________________________________________________
- 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 ;
//_____________________________________________________________________________
-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") ;
}
//_____________________________________________________________________________
-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
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+="." ;
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") ;
}
//_____________________________________________________________________________
-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 ;
}
//_____________________________________________________________________________
-void AliQualAssChecker::SetQAResultDirName(const char * name)
+void AliQAChecker::SetQAResultDirName(const char * name)
{
// Set the root directory where to store the QA status object
}
//_____________________________________________________________________________
-void AliQualAssChecker::SetRefDirName(const char * name)
+void AliQAChecker::SetRefDirName(const char * name)
{
// Set the root directory of reference data
-#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 */
//
// 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() ; }
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
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
/*
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)
}
//____________________________________________________________________________
-AliQualAssCheckerBase::AliQualAssCheckerBase(const AliQualAssCheckerBase& qadm) :
+AliQACheckerBase::AliQACheckerBase(const AliQACheckerBase& qadm) :
TNamed(qadm.GetName(), qadm.GetTitle()),
fDataSubDir(qadm.fDataSubDir),
fRefSubDir(qadm.fRefSubDir)
}
//____________________________________________________________________________
-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
}
//____________________________________________________________________________
-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
}
//____________________________________________________________________________
-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. ;
}
}
//____________________________________________________________________________
-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. ;
}
}
//____________________________________________________________________________
-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)
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() ;
}
-#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 */
/*
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 ;
// --- 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:
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
};
// --- 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),
}
//____________________________________________________________________________
-AliQualAssDataMaker::AliQualAssDataMaker(const AliQualAssDataMaker& qadm) :
+AliQADataMaker::AliQADataMaker(const AliQADataMaker& qadm) :
TNamed(qadm.GetName(), qadm.GetTitle()),
fOutput(qadm.fOutput),
fDetectorDir(qadm.fDetectorDir),
}
//____________________________________________________________________________
-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
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) ;
AliError("Wrong data type") ;
break ;
}
- case AliQualAss::kHITS:
+ case AliQA::kHITS:
{
AliInfo("Processing Hits QA") ;
TClonesArray * hits = dynamic_cast<TClonesArray *>(data) ;
AliError("Wrong type of hits container") ;
break ;
}
- case AliQualAss::kSDIGITS:
+ case AliQA::kSDIGITS:
{
AliInfo("Processing SDigits QA") ;
TClonesArray * sdigits = dynamic_cast<TClonesArray *>(data) ;
AliError("Wrong type of sdigits container") ;
break ;
}
- case AliQualAss::kDIGITS:
+ case AliQA::kDIGITS:
{
TClonesArray * digits = dynamic_cast<TClonesArray *>(data) ;
if (digits)
AliError("Wrong type of digits container") ;
break ;
}
- case AliQualAss::kRECPOINTS:
+ case AliQA::kRECPOINTS:
{
AliInfo("Processing RecPoints QA") ;
TTree * recpoints = dynamic_cast<TTree *>(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)
// 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)
// AliError("Wrong type of recparticles container") ;
break ;
- case AliQualAss::kESDS:
+ case AliQA::kESDS:
{
AliInfo("Processing ESDs QA") ;
AliESDEvent * esd = dynamic_cast<AliESDEvent *>(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
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() ;
}
//____________________________________________________________________________
-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
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 ;
}
-#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 */
// --- 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) ; }
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");}
Int_t fCycleCounter ; //! cycle counter
Int_t fRun ; //! run number
- ClassDef(AliQualAssDataMaker,1) // description
+ ClassDef(AliQADataMaker,1) // description
};
-#endif // AliQualAssDataMaker_H
+#endif // AliQADataMaker_H
#include "AliAODVertex.h"
#include "AliAODCluster.h"
-#include "AliQualAssDataMaker.h"
+#include "AliQADataMaker.h"
//#include "TMemStatManager.h" // memory snapshots
#include "AliSysInfo.h" // memory snapshots
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
- fQualAssDataMaker[iDet] = NULL;
+ fQADataMaker[iDet] = NULL;
fQACycles[iDet] = 999999;
}
AliPID pid;
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++) {
}
if (!fFillESD.IsNull())
- RunQualAss(fFillESD.Data(), esd);
+ RunQA(fFillESD.Data(), esd);
// fill Event header information from the RawEventHeader
if (fRawReader){FillRawEventHeaderESD(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;
-
- 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);
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]));
}
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;
}
//_____________________________________________________________________________
-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
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]));
}
class AliESDEvent;
class TFile;
class TTree;
-class AliQualAssDataMaker;
+class AliQADataMaker;
class AliReconstruction: public TNamed {
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:
//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 *******************
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
#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
AliCodeTimer.cxx \
AliFstream.cxx \
AliCTPRawData.cxx \
-AliQualAss.cxx \
-AliQualAssDataMaker.cxx \
-AliQualAssChecker.cxx \
-AliQualAssCheckerBase.cxx
+AliQA.cxx \
+AliQADataMaker.cxx \
+AliQAChecker.cxx \
+AliQACheckerBase.cxx
git://git.uio.no / u/mrichter/AliRoot.git / commitdiff