// --- AliRoot header files ---
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliACORDEQAChecker.h"
#include "AliCDBEntry.h"
ClassImp(AliACORDEQAChecker)
//____________________________________________________________________________
-Double_t * AliACORDEQAChecker::Check(AliQA::ALITASK_t /*index*/)
+Double_t * AliACORDEQAChecker::Check(AliQAv1::ALITASK_t /*index*/)
{
Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
}
//__________________________________________________________________
-Double_t * AliACORDEQAChecker::Check(AliQA::ALITASK_t /*index*/, TObjArray ** list)
+Double_t * AliACORDEQAChecker::Check(AliQAv1::ALITASK_t /*index*/, TObjArray ** list)
{
// We added one check to the ACORDE's QA histograms:
// Look at the QAref data for ACORDE
- char * acoOCDBDir = Form("ACORDE/%s/%s",AliQA::GetRefOCDBDirName(),AliQA::GetRefDataDirName());
+ char * acoOCDBDir = Form("ACORDE/%s/%s",AliQAv1::GetRefOCDBDirName(),AliQAv1::GetRefDataDirName());
AliCDBEntry *acoQARefDir = AliQAManager::QAManager()->Get(acoOCDBDir);
// AliACORDEQAChecker(const AliACORDEQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()) {;} // constructor
virtual ~AliACORDEQAChecker() {;} // destructor
- virtual Double_t * Check(AliQA::ALITASK_t index) ;
- virtual Double_t * Check(AliQA::ALITASK_t index, TObjArray ** list) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t index) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** list) ;
Double_t CheckAcordeRefHits(TObjArray *AcordeList, TObjArray *AcordeRef) const;
ClassImp(AliACORDEQADataMaker)
//____________________________________________________________________________
-AliACORDEQADataMaker::AliACORDEQADataMaker():AliQADataMaker(AliQA::GetDetName(AliQA::kACORDE), "ACORDE Quality Assurance Data Maker")
+AliACORDEQADataMaker::AliACORDEQADataMaker():AliQADataMaker(AliQAv1::GetDetName(AliQAv1::kACORDE), "ACORDE Quality Assurance Data Maker")
{
// Acorde QA Data Maker
}
virtual Int_t Add2RecPointsList(TH1*, Int_t){return 0;};
virtual Int_t Add2RawsList(TH1*, Int_t){return 0;};
virtual Int_t Add2SDigitsList(TH1*, Int_t){return 0;};
- virtual void Exec(AliQA::TASKINDEX_t, TObject*){};
- virtual void EndOfCycle(AliQA::TASKINDEX_t){};
+ virtual void Exec(AliQAv1::TASKINDEX_t, TObject*){};
+ virtual void EndOfCycle(AliQAv1::TASKINDEX_t){};
virtual Int_t Add2ESDsList(TH1*, Int_t){return 0;};
virtual TH1* GetDigitsData(Int_t){return 0;};
virtual TH1* GetESDsData(Int_t){return 0;};
virtual TH1* GetRecPointsData(Int_t){return 0;};
virtual TH1* GetRawsData(Int_t){return 0;};
virtual TH1* GetSDigitsData(Int_t){return 0;};
- virtual TObjArray* Init(AliQA::TASKINDEX_t, Int_t, Int_t){return 0;};
- virtual void Init(AliQA::TASKINDEX_t, TObjArray*, Int_t, Int_t){};
- virtual void StartOfCycle(AliQA::TASKINDEX_t, Bool_t){};
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray*){};
+ virtual TObjArray* Init(AliQAv1::TASKINDEX_t, Int_t, Int_t){return 0;};
+ virtual void Init(AliQAv1::TASKINDEX_t, TObjArray*, Int_t, Int_t){};
+ virtual void StartOfCycle(AliQAv1::TASKINDEX_t, Bool_t){};
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray*){};
virtual void InitSDigits(){};
virtual void MakeHits(TClonesArray*){};
virtual void MakeDigits(TClonesArray*){};
ClassImp(AliACORDEQADataMakerRec)
//____________________________________________________________________________
-AliACORDEQADataMakerRec::AliACORDEQADataMakerRec():AliQADataMakerRec(AliQA::GetDetName(AliQA::kACORDE), "ACORDE Quality Assurance Data Maker")
+AliACORDEQADataMakerRec::AliACORDEQADataMakerRec():AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kACORDE), "ACORDE Quality Assurance Data Maker")
{
}
return *this;
}
//____________________________________________________________________________
-void AliACORDEQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliACORDEQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kACORDE, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kACORDE, task, list) ;
}
//____________________________________________________________________________
virtual void InitESDs() ; //book ESD QA histo
virtual void MakeRaws(AliRawReader* rawReader) ;
virtual void MakeESDs(AliESDEvent * esd) ; //Fill hit QA histo
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
virtual void StartOfDetectorCycle() ;
ClassDef(AliACORDEQADataMakerRec,1) // description
ClassImp(AliACORDEQADataMakerSim)
//____________________________________________________________________________
-AliACORDEQADataMakerSim::AliACORDEQADataMakerSim():AliQADataMakerSim(AliQA::GetDetName(AliQA::kACORDE), "ACORDE Quality Assurance Data Maker")
+AliACORDEQADataMakerSim::AliACORDEQADataMakerSim():AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kACORDE), "ACORDE Quality Assurance Data Maker")
{
}
//____________________________________________________________________________
return *this;
}
//____________________________________________________________________________
-void AliACORDEQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliACORDEQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
AliInfo("ACORDE---->Detector specific actions at END of cycle\n................\n");
- AliQAChecker::Instance()->Run(AliQA::kACORDE, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kACORDE, task, list) ;
}
//____________________________________________________________________________
void AliACORDEQADataMakerSim::StartOfDetectorCycle()
virtual void MakeHits(TClonesArray *) {} //Dummy for the moment
virtual void MakeDigits(TTree* digitsTree) ; //Fill Digit QA histo
virtual void MakeDigits(TClonesArray *) {} //Dummy for the moment
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
virtual void StartOfDetectorCycle() ;
ClassDef(AliACORDEQADataMakerSim,1) // description
// --- AliRoot header files ---
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliEMCALQAChecker.h"
//____________________________________________________________________________
AliEMCALQADataMakerRec::AliEMCALQADataMakerRec() :
- AliQADataMakerRec(AliQA::GetDetName(AliQA::kEMCAL), "EMCAL Quality Assurance Data Maker")
+ AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kEMCAL), "EMCAL Quality Assurance Data Maker")
{
// ctor
}
}
//____________________________________________________________________________
-void AliEMCALQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliEMCALQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kEMCAL, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kEMCAL, task, list) ;
}
//____________________________________________________________________________
virtual ~AliEMCALQADataMakerRec() {;} // dtor
private:
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
virtual void InitESDs() ;
virtual void InitRecPoints() ;
virtual void InitRaws() ;
//____________________________________________________________________________
AliEMCALQADataMakerSim::AliEMCALQADataMakerSim() :
- AliQADataMakerSim(AliQA::GetDetName(AliQA::kEMCAL), "EMCAL Quality Assurance Data Maker")
+ AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kEMCAL), "EMCAL Quality Assurance Data Maker")
{
// ctor
}
}
//____________________________________________________________________________
-void AliEMCALQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliEMCALQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kEMCAL, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kEMCAL, task, list) ;
}
//____________________________________________________________________________
virtual ~AliEMCALQADataMakerSim() {;} // dtor
private:
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
virtual void InitHits() ;
virtual void InitDigits() ;
virtual void InitSDigits() ;
// --- AliRoot header files ---
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliFMDQAChecker.h"
//_____________________________________________________________________
AliFMDQADataMakerRec::AliFMDQADataMakerRec() :
- AliQADataMakerRec(AliQA::GetDetName(AliQA::kFMD),
+ AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kFMD),
"FMD Quality Assurance Data Maker"),
fDigitsArray("AliFMDDigit", 0),
fRecPointsArray("AliFMDRecPoint", 1000)
//_____________________________________________________________________
AliFMDQADataMakerRec::AliFMDQADataMakerRec(const AliFMDQADataMakerRec& qadm)
- : AliQADataMakerRec(AliQA::GetDetName(AliQA::kFMD),
+ : AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kFMD),
"FMD Quality Assurance Data Maker"),
fDigitsArray(qadm.fDigitsArray),
fRecPointsArray(qadm.fRecPointsArray)
//_____________________________________________________________________
void
-AliFMDQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task,
+AliFMDQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task,
TObjArray ** list)
{
// Detector specific actions at end of cycle
"AliFMDQADataMakerRec","AliFMDQADataMakerRec",
"AliFMDQADataMakerRec::EndOfDetectorCycle",
"AliFMDQADataMakerRec.cxx",95);
- AliQAChecker::Instance()->Run(AliQA::kFMD, task, list);
+ AliQAChecker::Instance()->Run(AliQAv1::kFMD, task, list);
}
//_____________________________________________________________________
AliFMDQADataMakerRec& operator = (const AliFMDQADataMakerRec& qadm) ;
virtual ~AliFMDQADataMakerRec();
private:
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list);
virtual void InitESDs();
// virtual void InitDigits();
virtual void InitRecPoints();
#endif
//_____________________________________________________________________
AliFMDQADataMakerSim::AliFMDQADataMakerSim()
- : AliQADataMakerSim(AliQA::GetDetName(AliQA::kFMD),
+ : AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kFMD),
"FMD Quality Assurance Data Maker"),
fSDigitsArray("AliFMDSDigit", 1000),
fDigitsArray("AliFMDDigit", 1000),
}
//_____________________________________________________________________
-void AliFMDQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task,
+void AliFMDQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task,
TObjArray ** list)
{
//Detector specific actions at end of cycle
"AliFMDQADataMakerSim","AliFMDQADataMakerSim",
"AliFMDQADataMakerSim::EndOfDetectorCycle",
"AliFMDQADataMakerSim.cxx",83);
- AliQAChecker::Instance()->Run(AliQA::kFMD, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kFMD, task, list) ;
}
//_____________________________________________________________________
virtual ~AliFMDQADataMakerSim(); // dtor
private:
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list);
virtual void InitHits();
virtual void InitDigits();
// virtual void InitRaws() ;
// --- AliRoot header files ---
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliHMPIDQAChecker.h"
#include "AliCDBEntry.h"
ClassImp(AliHMPIDQAChecker)
//____________________________________________________________________________
-Double_t * AliHMPIDQAChecker::Check(AliQA::ALITASK_t /*index*/)
+Double_t * AliHMPIDQAChecker::Check(AliQAv1::ALITASK_t /*index*/)
{
Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
}
//_________________________________________________________________
-Double_t * AliHMPIDQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
+Double_t * AliHMPIDQAChecker::Check(AliQAv1::ALITASK_t index, TObjArray ** list)
{
//
// Main check function: Depending on the TASK, different checks are applied
Double_t * check = new Double_t[AliRecoParam::kNSpecies] ;
AliInfo(Form("Fix needed ....."));
- char * detOCDBDir = Form("HMPID/%s/%s", AliQA::GetRefOCDBDirName(), AliQA::GetRefDataDirName()) ;
+ char * detOCDBDir = Form("HMPID/%s/%s", AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName()) ;
AliCDBEntry *QARefRec = AliQAManager::QAManager()->Get(detOCDBDir);
if( !QARefRec){
AliInfo("QA reference data NOT retrieved for Reconstruction check. No HMPIDChecker ...exiting");
// checking for empy histograms
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
check[specie] = 1.0;
- if ( !AliQA::Instance()->IsEventSpecieSet(specie) )
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
continue ;
if(CheckEntries(list[specie]) == 0) {
AliWarning("histograms are empty");
}
// checking rec points
- if(index == AliQA::kREC) check[specie] = CheckRecPoints(list[specie],(TObjArray *)QARefRec->GetObject());
+ if(index == AliQAv1::kREC) check[specie] = CheckRecPoints(list[specie],(TObjArray *)QARefRec->GetObject());
//default check response. It will be changed when reasonable checks will be considered
else check[specie] = 0.7 ; // /-> Corresponds to kINFO see AliQACheckerBase::Run
AliHMPIDQAChecker(const AliHMPIDQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()) {;} // cpy ctor
virtual ~AliHMPIDQAChecker() {;} // dtor
- virtual Double_t * Check(AliQA::ALITASK_t /*index*/) ;
- virtual Double_t * Check(AliQA::ALITASK_t index, TObjArray ** list) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** list) ;
Double_t CheckEntries(TObjArray * list) const ;
Double_t CheckRecPoints(TObjArray *listrec, TObjArray *listref) const ;
//____________________________________________________________________________
AliHMPIDQADataMaker::AliHMPIDQADataMaker() :
- AliQADataMaker(AliQA::GetDetName(AliQA::kHMPID), "HMPID Quality Assurance Data Maker")
+ AliQADataMaker(AliQAv1::GetDetName(AliQAv1::kHMPID), "HMPID Quality Assurance Data Maker")
{
// ctor
}
}
-void AliHMPIDQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * obj)
+void AliHMPIDQADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX task, TObjArray * obj)
{
//Detector specific actions at end of cycle
// do the QA checking
-// AliQAChecker::Instance()->Run(AliQA::kHMPID, task, obj) ;
+// AliQAChecker::Instance()->Run(AliQAv1::kHMPID, task, obj) ;
}
private:
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * obj) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX, TObjArray * obj) ;
virtual void InitHits() ; //book hit QA histo
virtual void InitDigits() ; //book Digit QA histo
virtual void InitSDigits() ; //book SDigits QA histo
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
AliHMPIDQADataMakerRec::AliHMPIDQADataMakerRec() :
- AliQADataMakerRec(AliQA::GetDetName(AliQA::kHMPID), "HMPID Quality Assurance Data Maker"),fEvtRaw(0)
+ AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kHMPID), "HMPID Quality Assurance Data Maker"),fEvtRaw(0)
{
// ctor
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-void AliHMPIDQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray **histos)
+void AliHMPIDQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray **histos)
{
//Detector specific actions at end of cycle
// do the QA checking
- if(task==AliQA::kRAWS) {
+ if(task==AliQAv1::kRAWS) {
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
for(Int_t iddl=0;iddl<14;iddl++) {
TH1F *h = (TH1F*)histos[specie]->At(14+iddl); //ddl histos scaled by the number of events
}
}
- AliQAChecker::Instance()->Run(AliQA::kHMPID, task, histos);
+ AliQAChecker::Instance()->Run(AliQAv1::kHMPID, task, histos);
}
virtual void MakeRaws(AliRawReader* rawReader);
virtual void MakeESDs(AliESDEvent * esd) ; //Fill hit QA histo
virtual void StartOfDetectorCycle() ;
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** obj) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** obj) ;
Int_t fEvtRaw; //internal event counter for raw
ClassDef(AliHMPIDQADataMakerRec,1) // description
//____________________________________________________________________________
AliHMPIDQADataMakerSim::AliHMPIDQADataMakerSim() :
- AliQADataMakerSim(AliQA::GetDetName(AliQA::kHMPID), "HMPID Quality Assurance Data Maker")
+ AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kHMPID), "HMPID Quality Assurance Data Maker")
{
// ctor
}
}
-void AliHMPIDQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray **obj)
+void AliHMPIDQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray **obj)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kHMPID, task, obj) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kHMPID, task, obj) ;
}
private:
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** obj) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** obj) ;
virtual void InitHits() ; //book hit QA histo
virtual void InitDigits() ; //book Digit QA histo
virtual void InitSDigits() ; //book SDigits QA histo
// fRawReader->AddMajorErrorLog(kEoEDILOGICErr,Form("eoe dil %d != %d",da,dilogic));
// AliDebug(1,Form("Wrong DILOGIC address found in end-of-event: %d, expected %d!",da,dilogic));
// fNumOfErr[kEoEDILOGICErr]++;
-// return kFALSE; AliQAChecker::Instance()->Run(AliQA::kHMPID, task, obj) ;
+// return kFALSE; AliQAChecker::Instance()->Run(AliQAv1::kHMPID, task, obj) ;
// }
// UInt_t ca = (eOfEvent >> 22) & 0x1f;
}
//____________________________________________________________________________
-Double_t * AliITSQAChecker::Check(AliQA::ALITASK_t /*index*/)
+Double_t * AliITSQAChecker::Check(AliQAv1::ALITASK_t /*index*/)
{
Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
}
//____________________________________________________________________________
-Double_t * AliITSQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
+Double_t * AliITSQAChecker::Check(AliQAv1::ALITASK_t index, TObjArray ** list)
{
// Super-basic check on the QA histograms on the input list:
// look whether they are empty!
- if(index == AliQA::kESD){
+ if(index == AliQAv1::kESD){
Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
rv[specie] = 0.0 ;
- if ( !AliQA::Instance()->IsEventSpecieSet(specie) )
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
continue ;
AliDebug(1,"Checker for ESD");
Int_t tested = 0;
fSPDChecker->SetTaskOffset(fSPDOffset);
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
retval[specie] = 1.0 ;
- if ( AliQA::Instance()->IsEventSpecieSet(specie) ) {
+ if ( AliQAv1::Instance()->IsEventSpecieSet(specie) ) {
spdCheck = fSPDChecker->Check(index, list[specie]);
if(spdCheck<retval[specie])retval[specie] = spdCheck;
}
fSDDChecker->SetTaskOffset(fSDDOffset);
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
retval[specie] = 1.0 ;
- if ( AliQA::Instance()->IsEventSpecieSet(specie) ) {
+ if ( AliQAv1::Instance()->IsEventSpecieSet(specie) ) {
sddCheck = fSDDChecker->Check(index, list[specie]);
if(sddCheck<retval[specie])retval[specie] = sddCheck;
}
fSSDChecker->SetTaskOffset(fSSDOffset);
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
retval[specie] = 1.0 ;
- if ( AliQA::Instance()->IsEventSpecieSet(specie) ) {
+ if ( AliQAv1::Instance()->IsEventSpecieSet(specie) ) {
ssdCheck = fSSDChecker->Check(index, list[specie]);
if(ssdCheck<retval[specie])retval[specie] = ssdCheck;
}
class TH2F ;
// --- AliRoot header files ---
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQACheckerBase.h"
class AliITSQASPDChecker;
virtual void SetDetTaskOffset(Int_t subdet=0,Int_t offset=0);
protected:
- virtual Double_t * Check(AliQA::ALITASK_t /*index*/) ;
- virtual Double_t * Check(AliQA::ALITASK_t index, TObjArray ** list ) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** list ) ;
virtual void SetSPDTaskOffset(Int_t SPDOffset){fSPDOffset = SPDOffset;} ;
virtual void SetSDDTaskOffset(Int_t SDDOffset){fSDDOffset = SDDOffset;} ;
virtual void SetSSDTaskOffset(Int_t SSDOffset){fSSDOffset = SSDOffset;} ;
#include "AliITSQASDDDataMakerRec.h"
#include "AliITSQASSDDataMakerRec.h"
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliITSQAChecker.h"
#include "AliRawReader.h"
//____________________________________________________________________________
AliITSQADataMakerRec::AliITSQADataMakerRec(Bool_t kMode, Short_t subDet, Short_t ldc) :
-AliQADataMakerRec(AliQA::GetDetName(AliQA::kITS), "ITS Quality Assurance Data Maker"),
+AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kITS), "ITS Quality Assurance Data Maker"),
fkOnline(kMode),
fHLTMode(0),
fSubDetector(subDet),
}
//____________________________________________________________________________
-void AliITSQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray** list)
+void AliITSQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list)
{
// launch the QA checking
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
SetEventSpecie(specie) ;
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list[specie])\n");
+ AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list[specie])\n");
if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->EndOfDetectorCycle(task, list[specie]);
if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->EndOfDetectorCycle(task, list[specie]);
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->EndOfDetectorCycle(task, list[specie]);
qacb->SetDetTaskOffset(subdet,offset);
}
- qac->Run( AliQA::kITS , task, list);
+ qac->Run( AliQAv1::kITS , task, list);
}
}
}
//_________________________________________________________________
-Int_t AliITSQADataMakerRec::GetDetTaskOffset(Int_t subdet,AliQA::TASKINDEX_t task)
+Int_t AliITSQADataMakerRec::GetDetTaskOffset(Int_t subdet,AliQAv1::TASKINDEX_t task)
{
switch(subdet)
{
AliITSQADataMakerRec(const AliITSQADataMakerRec& qadm);
AliITSQADataMakerRec& operator = (const AliITSQADataMakerRec& qac);
virtual void StartOfDetectorCycle();
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list);
virtual void EndOfDetectorCycle(const char *fgDataName);
virtual void InitRaws();
virtual void InitRecPoints();
Bool_t GetHLTMode(){return fHLTMode;};
virtual ~AliITSQADataMakerRec(); // dtor
Short_t GetSubDet(){return fSubDetector;};
- Int_t GetDetTaskOffset(Int_t subdet,AliQA::TASKINDEX_t task);
+ Int_t GetDetTaskOffset(Int_t subdet,AliQAv1::TASKINDEX_t task);
private:
#include "AliITSQASDDDataMakerSim.h"
#include "AliITSQASSDDataMakerSim.h"
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliITSQAChecker.h"
#include "AliRawReader.h"
//____________________________________________________________________________
AliITSQADataMakerSim::AliITSQADataMakerSim(Short_t subDet) :
-AliQADataMakerSim(AliQA::GetDetName(AliQA::kITS), "ITS Quality Assurance Data Maker"),
+AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kITS), "ITS Quality Assurance Data Maker"),
fSubDetector(subDet),
fSPDDataMaker(NULL),
fSDDDataMaker(NULL),
}
//____________________________________________________________________________
-void AliITSQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray** list)
+void AliITSQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list)
{
// launch the QA checking
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
SetEventSpecie(specie) ;
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n");
+ AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->EndOfDetectorCycle(task, list[specie]);
if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->EndOfDetectorCycle(task, list[specie]);
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->EndOfDetectorCycle(task, list[specie]);
Int_t offset=GetDetTaskOffset(subdet, task);
qacb->SetDetTaskOffset(subdet,offset);
}
- qac->Run( AliQA::kITS , task, list);
+ qac->Run( AliQAv1::kITS , task, list);
}
}
//_________________________________________________________________
-Int_t AliITSQADataMakerSim::GetDetTaskOffset(Int_t subdet,AliQA::TASKINDEX_t task)
+Int_t AliITSQADataMakerSim::GetDetTaskOffset(Int_t subdet,AliQAv1::TASKINDEX_t task)
{
switch(subdet)
{
AliITSQADataMakerSim(const AliITSQADataMakerSim& qadm);
AliITSQADataMakerSim& operator = (const AliITSQADataMakerSim& qac);
virtual void StartOfDetectorCycle();
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list);
virtual void InitDigits();
virtual void InitSDigits();
virtual void InitHits();
virtual void MakeHits(TTree * hits);
virtual ~AliITSQADataMakerSim(); // dtor
Short_t GetSubDet(){return fSubDetector;};
- Int_t GetDetTaskOffset(Int_t subdet,AliQA::TASKINDEX_t task);
+ Int_t GetDetTaskOffset(Int_t subdet,AliQAv1::TASKINDEX_t task);
private:
}
//__________________________________________________________________
-Double_t AliITSQASDDChecker::Check(AliQA::ALITASK_t index, TObjArray * list)
+Double_t AliITSQASDDChecker::Check(AliQAv1::ALITASK_t index, TObjArray * list)
{
AliDebug(1,Form("AliITSQASDDChecker called with offset: %d\n", fSubDetOffset));
- char * detOCDBDir = Form("ITS/%s/%s", AliQA::GetRefOCDBDirName(), AliQA::GetRefDataDirName()) ;
+ char * detOCDBDir = Form("ITS/%s/%s", AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName()) ;
AliCDBEntry *QARefObj = AliQAManager::QAManager()->Get(detOCDBDir);
if( !QARefObj){
AliError("Calibration object retrieval failed! SDD will not be processed");
Double_t test = 0.0;
Int_t offset = 0;
- if(index==AliQA::kRAW){ //analizing RAWS
+ if(index==AliQAv1::kRAW){ //analizing RAWS
TH1F *ModPattern = (TH1F*)QARefObj->GetObject();
if (list->GetEntries() == 0){
test = 1. ; // nothing to check
} // if(index==0)
- if( index==AliQA::kREC){ //analizing RECP
+ if( index==AliQAv1::kREC){ //analizing RECP
//printf("analizing recp, offset %d \n",fSubDetOffset);
if (list->GetEntries() == 0){
test = 1. ; // nothing to check
class TH2F ;
// --- AliRoot header files ---
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQACheckerBase.h"
#include "AliITSQAChecker.h"
class AliITSLoader ;
AliITSQASDDChecker():fSubDetOffset(0) {;} // ctor
AliITSQASDDChecker& operator = (const AliITSQASDDChecker& qac) ; //operator =
virtual ~AliITSQASDDChecker() {;} // dtor
- Double_t Check(AliQA::ALITASK_t index, TObjArray * list);
+ Double_t Check(AliQAv1::ALITASK_t index, TObjArray * list);
void SetTaskOffset(Int_t TaskOffset);
private:
// --- AliRoot header files ---
#include "AliITSQASDDDataMakerRec.h"
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliRawReader.h"
#include "AliITSRawStream.h"
}
//____________________________________________________________________________
-void AliITSQASDDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TObjArray* /*list*/)
+void AliITSQASDDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)
{
// launch the QA checking
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n");
+ AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
}
//____________________________________________________________________________
//_______________________________________________________________
-Int_t AliITSQASDDDataMakerRec::GetOffset(AliQA::TASKINDEX_t task)
+Int_t AliITSQASDDDataMakerRec::GetOffset(AliQAv1::TASKINDEX_t task)
{
Int_t offset=0;
- if( task == AliQA::kRAWS )
+ if( task == AliQAv1::kRAWS )
{
offset=fGenRawsOffset;
}
else
- if( task == AliQA::kRECPOINTS )
+ if( task == AliQAv1::kRECPOINTS )
{
offset=fGenRecPointsOffset;
}
//_______________________________________________________________
-Int_t AliITSQASDDDataMakerRec::GetTaskHisto(AliQA::TASKINDEX_t task)
+Int_t AliITSQASDDDataMakerRec::GetTaskHisto(AliQAv1::TASKINDEX_t task)
{
Int_t histotot=0;
- if( task == AliQA::kRAWS )
+ if( task == AliQAv1::kRAWS )
{
histotot=fSDDhRawsTask ;
}
else
- if( task == AliQA::kRECPOINTS )
+ if( task == AliQAv1::kRECPOINTS )
{
histotot=fSDDhRecPointsTask;
}
/* $Id$ */
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliITSQADataMakerRec.h"
class TObjArray;
virtual void MakeRaws(AliRawReader *rawReader);
virtual void MakeRecPoints(TTree *clustersTree);
virtual void StartOfDetectorCycle();
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
virtual ~AliITSQASDDDataMakerRec(); // dtor
- Int_t GetOffset(AliQA::TASKINDEX_t task);
- Int_t GetTaskHisto(AliQA::TASKINDEX_t task);
+ Int_t GetOffset(AliQAv1::TASKINDEX_t task);
+ Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);
void SetHLTMode(Bool_t khltmode=kFALSE){fHLTMode=khltmode;};
Bool_t GetHLTMode(){return fHLTMode;};
// --- AliRoot header files ---\r
#include "AliITSQASDDDataMakerSim.h"\r
#include "AliLog.h"\r
-#include "AliQA.h"\r
+#include "AliQAv1.h"\r
#include "AliQAChecker.h"\r
#include "AliQADataMakerSim.h"\r
#include "AliITSQADataMakerSim.h"\r
}\r
\r
//____________________________________________________________________________ \r
-void AliITSQASDDDataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TObjArray* /*list*/)\r
+void AliITSQASDDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)\r
{\r
// launch the QA checking\r
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); \r
- //AliQAChecker::Instance()->Run( AliQA::kITS , task, list);\r
+ AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n"); \r
+ //AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);\r
}\r
\r
//____________________________________________________________________________ \r
\r
//_______________________________________________________________\r
\r
-Int_t AliITSQASDDDataMakerSim::GetOffset(AliQA::TASKINDEX_t task){\r
+Int_t AliITSQASDDDataMakerSim::GetOffset(AliQAv1::TASKINDEX_t task){\r
// Returns histogram offset according to the specified task\r
Int_t offset=0;\r
- if( task == AliQA::kHITS){\r
+ if( task == AliQAv1::kHITS){\r
offset=fGenOffsetH; \r
}\r
- else if( task == AliQA::kSDIGITS) {\r
+ else if( task == AliQAv1::kSDIGITS) {\r
offset=fGenOffsetS; \r
}\r
- else if( task == AliQA::kDIGITS) {\r
+ else if( task == AliQAv1::kDIGITS) {\r
offset=fGenOffsetD; \r
}\r
else {\r
\r
//_______________________________________________________________\r
\r
-Int_t AliITSQASDDDataMakerSim::GetTaskHisto(AliQA::TASKINDEX_t task) {\r
+Int_t AliITSQASDDDataMakerSim::GetTaskHisto(AliQAv1::TASKINDEX_t task) {\r
// Returns the number of booked histograms for the selected task\r
Int_t histotot=0;\r
- if( task == AliQA::kHITS) {\r
+ if( task == AliQAv1::kHITS) {\r
histotot=fSDDhHTask ; \r
}\r
- else if( task == AliQA::kSDIGITS) {\r
+ else if( task == AliQAv1::kSDIGITS) {\r
histotot=fSDDhSTask; \r
}\r
- else if( task == AliQA::kDIGITS) {\r
+ else if( task == AliQAv1::kDIGITS) {\r
histotot=fSDDhDTask ; \r
}\r
else {\r
\r
/* $Id$ */\r
\r
-#include "AliQA.h"\r
+#include "AliQAv1.h"\r
class AliITSQADataMakerSim;\r
class AliRunLoader;\r
class AliRun;\r
AliITSQASDDDataMakerSim& operator = (const AliITSQASDDDataMakerSim& qac);\r
\r
virtual void StartOfDetectorCycle();\r
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);\r
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);\r
virtual ~AliITSQASDDDataMakerSim() {;} // dtor\r
virtual void InitDigits();\r
virtual void InitSDigits();\r
virtual void MakeDigits(TTree * digits);\r
virtual void MakeSDigits(TTree * sdigits);\r
virtual void MakeHits(TTree * hits);\r
- Int_t GetOffset(AliQA::TASKINDEX_t task);\r
- Int_t GetTaskHisto(AliQA::TASKINDEX_t task);\r
+ Int_t GetOffset(AliQAv1::TASKINDEX_t task);\r
+ Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);\r
\r
private:\r
\r
//__________________________________________________________________
-Double_t AliITSQASPDChecker::Check(AliQA::ALITASK_t /*index*/, TObjArray * list)
+Double_t AliITSQASPDChecker::Check(AliQAv1::ALITASK_t /*index*/, TObjArray * list)
{
AliDebug(1,Form("AliITSQASPDChecker called with offset: %d\n", fSubDetOffset));
class TH2F ;
// --- AliRoot header files ---
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQACheckerBase.h"
#include "AliITSQAChecker.h"
class AliITSLoader ;
AliITSQASPDChecker():fSubDetOffset(0) {;} // ctor
AliITSQASPDChecker& operator = (const AliITSQASPDChecker& qac) ; //operator =
virtual ~AliITSQASPDChecker() {;} // dtor
- Double_t Check(AliQA::ALITASK_t index, TObjArray * list);
+ Double_t Check(AliQAv1::ALITASK_t index, TObjArray * list);
void SetTaskOffset(Int_t TaskOffset);
private:
#include "AliITSQADataMakerRec.h"
#include "AliITSQASPDDataMakerRec.h"
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliRawReader.h"
#include "AliITSRawStreamSPD.h"
#include "AliITSRawStreamSPDErrorLog.h"
}
//____________________________________________________________________________
-void AliITSQASPDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TObjArray* /*list*/)
+void AliITSQASPDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)
{
// launch the QA checking
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n");
+ AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
- //AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
+ //AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);
}
//____________________________________________________________________________
//_______________________________________________________________
-Int_t AliITSQASPDDataMakerRec::GetOffset(AliQA::TASKINDEX_t task) {
+Int_t AliITSQASPDDataMakerRec::GetOffset(AliQAv1::TASKINDEX_t task) {
// Returns offset number according to the specified task
Int_t offset=0;
- if( task == AliQA::kRAWS ) {
+ if( task == AliQAv1::kRAWS ) {
offset=fGenRawsOffset;
}
- else if( task == AliQA::kRECPOINTS ) {
+ else if( task == AliQAv1::kRECPOINTS ) {
offset=fGenRecPointsOffset;
}
else {
//_______________________________________________________________
-Int_t AliITSQASPDDataMakerRec::GetTaskHisto(AliQA::TASKINDEX_t task) {
+Int_t AliITSQASPDDataMakerRec::GetTaskHisto(AliQAv1::TASKINDEX_t task) {
// Returns the number of histograms associated to the specified task
Int_t histotot=0;
- if( task == AliQA::kRAWS ) {
+ if( task == AliQAv1::kRAWS ) {
histotot=fSPDhRawsTask;
}
- else if( task == AliQA::kRECPOINTS ){
+ else if( task == AliQAv1::kRECPOINTS ){
histotot=fSPDhRecPointsTask;
}
else {
class AliRawReader;
class AliITSRawStreamSPDErrorLog;
class AliITSQADataMakerRec;
-class AliQA;
+class AliQAv1;
class AliITSQASPDDataMakerRec : public TObject {
virtual void MakeRaws(AliRawReader *rawReader);
virtual void MakeRecPoints(TTree *clustersTree);
virtual void StartOfDetectorCycle();
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
virtual ~AliITSQASPDDataMakerRec(); // dtor
- Int_t GetOffset(AliQA::TASKINDEX_t task);
- Int_t GetTaskHisto(AliQA::TASKINDEX_t task);
+ Int_t GetOffset(AliQAv1::TASKINDEX_t task);
+ Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);
private:
#include "AliRun.h"
#include "AliITSQADataMakerSim.h"
#include "AliITSQASPDDataMakerSim.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliITSdigit.h"
#include "AliITSdigitSPD.h"
}
//____________________________________________________________________________
-void AliITSQASPDDataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TObjArray* /*list*/)
+void AliITSQASPDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)
{
// launch the QA checking
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n");
+ AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
- //AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
+ //AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);
}
//____________________________________________________________________________
//_______________________________________________________________
-Int_t AliITSQASPDDataMakerSim::GetOffset(AliQA::TASKINDEX_t task){
+Int_t AliITSQASPDDataMakerSim::GetOffset(AliQAv1::TASKINDEX_t task){
// Returns histogram offset according to the specified task
Int_t offset=0;
- if( task == AliQA::kHITS){
+ if( task == AliQAv1::kHITS){
offset=fGenOffsetH;
}
- else if( task == AliQA::kSDIGITS) {
+ else if( task == AliQAv1::kSDIGITS) {
offset=fGenOffsetS;
}
- else if( task == AliQA::kDIGITS) {
+ else if( task == AliQAv1::kDIGITS) {
offset=fGenOffsetD;
}
else {
//_______________________________________________________________
-Int_t AliITSQASPDDataMakerSim::GetTaskHisto(AliQA::TASKINDEX_t task) {
+Int_t AliITSQASPDDataMakerSim::GetTaskHisto(AliQAv1::TASKINDEX_t task) {
// Returns the number of booked histograms for the selected task
Int_t histotot=0;
- if( task == AliQA::kHITS) {
+ if( task == AliQAv1::kHITS) {
histotot=fSPDhHTask ;
}
- else if( task == AliQA::kSDIGITS) {
+ else if( task == AliQAv1::kSDIGITS) {
histotot=fSPDhSTask;
}
- else if( task == AliQA::kDIGITS) {
+ else if( task == AliQAv1::kDIGITS) {
histotot=fSPDhDTask ;
}
else {
/* $Id$ */
-#include "AliQA.h"
+#include "AliQAv1.h"
class AliITSQADataMakerSim;
class TObjArray;
class TClonesArray;
AliITSQASPDDataMakerSim& operator = (const AliITSQASPDDataMakerSim& qac);
virtual void StartOfDetectorCycle();
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
virtual ~AliITSQASPDDataMakerSim() {;} // dtor
virtual void InitDigits();
virtual void InitSDigits();
virtual void MakeDigits(TTree * digits);
virtual void MakeSDigits(TTree * sdigits);
virtual void MakeHits(TTree * hits);
- Int_t GetOffset(AliQA::TASKINDEX_t task);
- Int_t GetTaskHisto(AliQA::TASKINDEX_t task);
+ Int_t GetOffset(AliQAv1::TASKINDEX_t task);
+ Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);
//Int_t GetOffsetH() { return fGenOffsetH; }
//Int_t GetOffsetS() { return fGenOffsetS; }
//Int_t GetOffsetD() { return fGenOffsetD; }
}
//__________________________________________________________________
-Double_t AliITSQASSDChecker::Check(AliQA::ALITASK_t /*index*/, TObjArray * list) {
+Double_t AliITSQASSDChecker::Check(AliQAv1::ALITASK_t /*index*/, TObjArray * list) {
AliDebug(1,Form("AliITSQASSDChecker called with offset: %d\n", fSubDetOffset));
Double_t test = 0.0 ;
class TH2F ;
// --- AliRoot header files ---
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQACheckerBase.h"
#include "AliITSQAChecker.h"
class AliITSLoader ;
AliITSQASSDChecker():fSubDetOffset(0) {;} // ctor
AliITSQASSDChecker& operator = (const AliITSQASSDChecker& qac) ; //operator =
virtual ~AliITSQASSDChecker() {;} // dtor
- Double_t Check(AliQA::ALITASK_t /*index*/, TObjArray * /*list*/);
+ Double_t Check(AliQAv1::ALITASK_t /*index*/, TObjArray * /*list*/);
void SetTaskOffset(Int_t TaskOffset);
#include "AliITSQASSDDataMakerRec.h"
#include "AliQADataMakerRec.h"
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliRawReader.h"
#include "AliRawReaderRoot.h"
}
//____________________________________________________________________________
-void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TObjArray* /*list*/)
+void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)
{
// launch the QA checking
if ( fAliITSQADataMakerRec->GetRawsData(0) == NULL ) // Raws not defined
return ;
// launch the QA checking
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n");
+ AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
AliInfo(Form("Offset: %d\n",fGenRawsOffset));
//Data size per DDL
for(Int_t i = 0; i < fgkNumOfDDLs; i++) {
fSSDEventPerCycle = 0;
- // AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
+ // AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);
}
//____________________________________________________________________________
}
//____________________________________________________________________________
-Int_t AliITSQASSDDataMakerRec::GetOffset(AliQA::TASKINDEX_t task) {
+Int_t AliITSQASSDDataMakerRec::GetOffset(AliQAv1::TASKINDEX_t task) {
// Returns offset number according to the specified task
Int_t offset=0;
- if( task == AliQA::kRAWS ) {
+ if( task == AliQAv1::kRAWS ) {
offset=fGenRawsOffset;
}
- else if( task == AliQA::kRECPOINTS ) {
+ else if( task == AliQAv1::kRECPOINTS ) {
offset=fGenRecPointsOffset;
}
else {
}
//____________________________________________________________________________
-Int_t AliITSQASSDDataMakerRec::GetTaskHisto(AliQA::TASKINDEX_t task) {
+Int_t AliITSQASSDDataMakerRec::GetTaskHisto(AliQAv1::TASKINDEX_t task) {
// Returns the number of histograms associated to the specified task
Int_t histotot=0;
- if( task == AliQA::kRAWS ) {
+ if( task == AliQAv1::kRAWS ) {
histotot=fSSDhRawsTask;
}
- else if( task == AliQA::kRECPOINTS ){
+ else if( task == AliQAv1::kRECPOINTS ){
histotot=fSSDhRecPointsTask;
}
else {
// W. Ferrarese + P. Cerello Feb 2008
// INFN Torino
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliITSQADataMakerRec.h"
#include "AliQADataMakerRec.h"
virtual void MakeRaws(AliRawReader *rawReader);
virtual void MakeRecPoints(TTree *clustersTree);
virtual void StartOfDetectorCycle();
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
virtual ~AliITSQASSDDataMakerRec(); // dtor
- Int_t GetOffset(AliQA::TASKINDEX_t task);
- Int_t GetTaskHisto(AliQA::TASKINDEX_t task);
+ Int_t GetOffset(AliQAv1::TASKINDEX_t task);
+ Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);
private:
#include "AliITSQADataMakerSim.h"
#include "AliITSQASSDDataMakerSim.h"
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliRawReader.h"
}
//____________________________________________________________________________
-void AliITSQASSDDataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TObjArray* /*list*/) {
+void AliITSQASSDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/) {
// launch the QA checking
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n");
+ AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
-// AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
+// AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);
}
//____________________________________________________________________________
//____________________________________________________________________________
-Int_t AliITSQASSDDataMakerSim::GetOffset(AliQA::TASKINDEX_t task){
+Int_t AliITSQASSDDataMakerSim::GetOffset(AliQAv1::TASKINDEX_t task){
// Returns histogram offset according to the specified task
Int_t offset=0;
- if( task == AliQA::kHITS){
+ if( task == AliQAv1::kHITS){
offset=fGenOffsetH;
}
- else if( task == AliQA::kSDIGITS) {
+ else if( task == AliQAv1::kSDIGITS) {
offset=fGenOffsetS;
}
- else if( task == AliQA::kDIGITS) {
+ else if( task == AliQAv1::kDIGITS) {
offset=fGenOffsetD;
}
else {
//____________________________________________________________________________
-Int_t AliITSQASSDDataMakerSim::GetTaskHisto(AliQA::TASKINDEX_t task) {
+Int_t AliITSQASSDDataMakerSim::GetTaskHisto(AliQAv1::TASKINDEX_t task) {
// Returns the number of booked histograms for the selected task
Int_t histotot=0;
- if( task == AliQA::kHITS) {
+ if( task == AliQAv1::kHITS) {
histotot=fSSDhHTask ;
}
- else if( task == AliQA::kSDIGITS) {
+ else if( task == AliQAv1::kSDIGITS) {
histotot=fSSDhSTask;
}
- else if( task == AliQA::kDIGITS) {
+ else if( task == AliQAv1::kDIGITS) {
histotot=fSSDhDTask ;
}
else {
// W. Ferrarese + P. Cerello Feb 2008
// SSD QA part: P. Christakoglou
-#include "AliQA.h"
+#include "AliQAv1.h"
class AliITSQADataMakerSim;
class TObjArray;
class TClonesArray;
AliITSQASSDDataMakerSim& operator = (const AliITSQASSDDataMakerSim& qac);
virtual void StartOfDetectorCycle();
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
virtual ~AliITSQASSDDataMakerSim() {;} // dtor
virtual void InitDigits();
virtual void InitSDigits();
virtual void MakeDigits(TTree * digits);
virtual void MakeSDigits(TTree * sdigits);
virtual void MakeHits(TTree * hits);
- Int_t GetOffset(AliQA::TASKINDEX_t task);
- Int_t GetTaskHisto(AliQA::TASKINDEX_t task);
+ Int_t GetOffset(AliQAv1::TASKINDEX_t task);
+ Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);
private:
#include "AliMUONPadStatusMaker.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliMUON2DMap.h"
#include "AliMUON2DStoreValidator.h"
fPedestals->ClassName(),
fGains->ClassName()));
- TString qaFileName(AliQA::GetQADataFileName("MUON",calibData.RunNumber()));
+ TString qaFileName(AliQAv1::GetQADataFileName("MUON",calibData.RunNumber()));
// search the QA file in memory first.
TFile* f = static_cast<TFile*>(gROOT->GetListOfFiles()->FindObject(qaFileName.Data()));
#include "AliLog.h"
#include "AliMUONVTrackerData.h"
#include "AliMpManuIterator.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include <TDirectory.h>
#include <TH1.h>
//______________________________________________________________________________
Double_t *
-AliMUONQAChecker::Check(AliQA::ALITASK_t /*index*/)
+AliMUONQAChecker::Check(AliQAv1::ALITASK_t /*index*/)
{
/// Check data
//______________________________________________________________________________
Double_t *
-AliMUONQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
+AliMUONQAChecker::Check(AliQAv1::ALITASK_t index, TObjArray ** list)
{
/// Check objects in list
- if ( index == AliQA::kRAW )
+ if ( index == AliQAv1::kRAW )
{
return CheckRaws(list);
}
- if ( index == AliQA::kREC)
+ if ( index == AliQAv1::kREC)
{
return CheckRecPoints(list);
}
- if ( index == AliQA::kESD )
+ if ( index == AliQAv1::kESD )
{
return CheckESD(list);
}
if ( value != 1.0 )
{
- histo.SetBit(AliQA::GetQABit());
+ histo.SetBit(AliQAv1::GetQABit());
}
return value;
}
//______________________________________________________________________________
-void AliMUONQAChecker::Init(const AliQA::DETECTORINDEX_t det)
+void AliMUONQAChecker::Init(const AliQAv1::DETECTORINDEX_t det)
{
// intialises QA and QA checker settings
- AliQA::Instance(det) ;
- Float_t hiValue[AliQA::kNBIT] ;
- Float_t lowValue[AliQA::kNBIT] ;
- lowValue[AliQA::kINFO] = 0.999 ;
- hiValue[AliQA::kINFO] = 1.0 ;
- hiValue[AliQA::kWARNING] = 0.99 ;
- lowValue[AliQA::kWARNING] = 0.5 ;
- lowValue[AliQA::kERROR] = 0.0 ;
- hiValue[AliQA::kERROR] = 0.5 ;
- lowValue[AliQA::kFATAL] = -1.0 ;
- hiValue[AliQA::kFATAL] = 0.0 ;
+ AliQAv1::Instance(det) ;
+ Float_t hiValue[AliQAv1::kNBIT] ;
+ Float_t lowValue[AliQAv1::kNBIT] ;
+ lowValue[AliQAv1::kINFO] = 0.999 ;
+ hiValue[AliQAv1::kINFO] = 1.0 ;
+ hiValue[AliQAv1::kWARNING] = 0.99 ;
+ lowValue[AliQAv1::kWARNING] = 0.5 ;
+ lowValue[AliQAv1::kERROR] = 0.0 ;
+ hiValue[AliQAv1::kERROR] = 0.5 ;
+ lowValue[AliQAv1::kFATAL] = -1.0 ;
+ hiValue[AliQAv1::kFATAL] = 0.0 ;
SetHiLo(&hiValue[0], &lowValue[0]) ;
}
//______________________________________________________________________________
void
-AliMUONQAChecker::SetQA(AliQA::ALITASK_t index, Double_t * value) const
+AliMUONQAChecker::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
{
/// sets the QA according the return value of the Check
- AliQA * qa = AliQA::Instance(index);
+ AliQAv1 * qa = AliQAv1::Instance(index);
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- qa->UnSet(AliQA::kFATAL, specie);
- qa->UnSet(AliQA::kWARNING, specie);
- qa->UnSet(AliQA::kERROR, specie);
- qa->UnSet(AliQA::kINFO, specie);
+ qa->UnSet(AliQAv1::kFATAL, specie);
+ qa->UnSet(AliQAv1::kWARNING, specie);
+ qa->UnSet(AliQAv1::kERROR, specie);
+ qa->UnSet(AliQAv1::kINFO, specie);
if ( ! value ) { // No checker is implemented, set all QA to Fatal
- qa->Set(AliQA::kFATAL, specie) ;
+ qa->Set(AliQAv1::kFATAL, specie) ;
} else {
- if ( value[specie] >= fLowTestValue[AliQA::kFATAL] && value[specie] < fUpTestValue[AliQA::kFATAL] )
- qa->Set(AliQA::kFATAL, specie) ;
- else if ( value[specie] > fLowTestValue[AliQA::kERROR] && value[specie] <= fUpTestValue[AliQA::kERROR] )
- qa->Set(AliQA::kERROR, specie) ;
- else if ( value[specie] > fLowTestValue[AliQA::kWARNING] && value[specie] <= fUpTestValue[AliQA::kWARNING] )
- qa->Set(AliQA::kWARNING, specie) ;
- else if ( value[specie] > fLowTestValue[AliQA::kINFO] && value[specie] <= fUpTestValue[AliQA::kINFO] )
- qa->Set(AliQA::kINFO, specie) ;
+ if ( value[specie] >= fLowTestValue[AliQAv1::kFATAL] && value[specie] < fUpTestValue[AliQAv1::kFATAL] )
+ qa->Set(AliQAv1::kFATAL, specie) ;
+ else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] && value[specie] <= fUpTestValue[AliQAv1::kERROR] )
+ qa->Set(AliQAv1::kERROR, specie) ;
+ else if ( value[specie] > fLowTestValue[AliQAv1::kWARNING] && value[specie] <= fUpTestValue[AliQAv1::kWARNING] )
+ qa->Set(AliQAv1::kWARNING, specie) ;
+ else if ( value[specie] > fLowTestValue[AliQAv1::kINFO] && value[specie] <= fUpTestValue[AliQAv1::kINFO] )
+ qa->Set(AliQAv1::kINFO, specie) ;
}
}
}
AliMUONQAChecker(const AliMUONQAChecker& qac);
virtual ~AliMUONQAChecker();
- virtual void Init(const AliQA::DETECTORINDEX_t det) ;
+ virtual void Init(const AliQAv1::DETECTORINDEX_t det) ;
protected:
using AliQACheckerBase::Check;
- virtual Double_t * Check(AliQA::ALITASK_t index) ;
- virtual Double_t * Check(AliQA::ALITASK_t index, TObjArray ** list) ;
- virtual void SetQA(AliQA::ALITASK_t index, Double_t * value) const ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t index) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** list) ;
+ virtual void SetQA(AliQAv1::ALITASK_t index, Double_t * value) const ;
Double_t * CheckRaws(TObjArray** list);
Double_t * CheckRecPoints(TObjArray** list);
//____________________________________________________________________________
AliMUONQADataMakerRec::AliMUONQADataMakerRec() :
-AliQADataMakerRec(AliQA::GetDetName(AliQA::kMUON), "MUON Quality Assurance Data Maker"),
+AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kMUON), "MUON Quality Assurance Data Maker"),
fIsInitRaws(kFALSE),
fIsInitRecPointsTracker(kFALSE),
fIsInitRecPointsTrigger(kFALSE),
}
//____________________________________________________________________________
-void AliMUONQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray** list)
+void AliMUONQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list)
{
///Detector specific actions at end of cycle
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
SetEventSpecie(specie) ;
- if ( task == AliQA::kRAWS && fTrackerDataMaker )
+ if ( task == AliQAv1::kRAWS && fTrackerDataMaker )
{
TIter next(list[specie]);
TObject* o;
}
// Normalize RecPoints histos
- if ( task == AliQA::kRECPOINTS ) {
+ if ( task == AliQAv1::kRECPOINTS ) {
TH1* hTrackerClusterChargePerChMean = GetRecPointsData(kTrackerClusterChargePerChMean);
TH1* hTrackerClusterChargePerChSigma = GetRecPointsData(kTrackerClusterChargePerChSigma);
}
// Normalize ESD histos
- if ( task == AliQA::kESDS ) {
+ if ( task == AliQAv1::kESDS ) {
Double_t nTracks = GetESDsData(kESDnClustersPerTrack)->GetEntries();
if (nTracks <= 0) continue;
}
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kMUON, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kMUON, task, list) ;
}
//____________________________________________________________________________
}
//____________________________________________________________________________
-void AliMUONQADataMakerRec::DisplayTriggerInfo(AliQA::TASKINDEX_t task)
+void AliMUONQADataMakerRec::DisplayTriggerInfo(AliQAv1::TASKINDEX_t task)
{
//
/// Display trigger information in a user-friendly way:
/// from local board and strip numbers to their position on chambers
//
- if(task!=AliQA::kRECPOINTS && task!=AliQA::kRAWS) return;
+ if(task!=AliQAv1::kRECPOINTS && task!=AliQAv1::kRAWS) return;
AliMUONTriggerDisplay triggerDisplay;
for (Int_t iCath = 0; iCath < AliMpConstants::NofCathodes(); iCath++)
{
- if(task==AliQA::kRECPOINTS){
+ if(task==AliQAv1::kRECPOINTS){
ERecPoints hindex
= ( iCath == 0 ) ? kTriggerDigitsBendPlane : kTriggerDigitsNonBendPlane;
histoStrips = (TH3F*)GetRecPointsData(hindex);
}
- else if(task==AliQA::kRAWS){
+ else if(task==AliQAv1::kRAWS){
ERaw hindex
= ( iCath == 0 ) ? kTriggerScalersBP : kTriggerScalersNBP;
histoStrips = (TH3F*)GetRawsData(hindex);
for (Int_t iChamber = 0; iChamber < AliMpConstants::NofTriggerChambers(); iChamber++)
{
- if(task==AliQA::kRECPOINTS){
+ if(task==AliQAv1::kRECPOINTS){
histoDisplayStrips = (TH2F*)GetRecPointsData(kTriggerDigitsDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
}
- else if(task==AliQA::kRAWS){
+ else if(task==AliQAv1::kRAWS){
histoDisplayStrips = (TH2F*)GetRawsData(kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
}
Int_t bin = histoStrips->GetXaxis()->FindBin(11+iChamber);
histoStrips->GetXaxis()->SetRange(bin,bin);
TH2F* inputHisto = (TH2F*)histoStrips->Project3D("zy");
triggerDisplay.FillDisplayHistogram(inputHisto, histoDisplayStrips, AliMUONTriggerDisplay::kDisplayStrips, iCath, iChamber);
- if(task==AliQA::kRAWS) {
+ if(task==AliQAv1::kRAWS) {
Float_t acquisitionTime = ((TH1F*)GetRawsData(kTriggerScalersTime))->GetBinContent(1);
histoDisplayStrips->Scale(1./acquisitionTime);
}
} // iChamber
} // iCath
- if(task==AliQA::kRAWS){
+ if(task==AliQAv1::kRAWS){
TH2F* histoI = (TH2F*) GetRawsData(kTriggerRPCi);
TH2F* histoHV = (TH2F*) GetRawsData(kTriggerRPChv);
FillTriggerDCSHistos();
}
}
- if(task==AliQA::kRECPOINTS){
+ if(task==AliQAv1::kRECPOINTS){
TH1F* histoBoards = (TH1F*)GetRecPointsData(kTriggeredBoards);
TH2F* histoDisplayBoards = (TH2F*)GetRecPointsData(kTriggerBoardsDisplay);
triggerDisplay.FillDisplayHistogram(histoBoards, histoDisplayBoards, AliMUONTriggerDisplay::kDisplayBoards, 0, 0);
virtual void MakeRecPoints(TTree* recpo);
virtual void MakeESDs(AliESDEvent* esd) ;
- virtual void DefaultEndOfDetectorCycle(AliQA::TASKINDEX_t) {}
+ virtual void DefaultEndOfDetectorCycle(AliQAv1::TASKINDEX_t) {}
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray** list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list);
private:
/// Raw histograms indices
private:
void Ctor();
- void DisplayTriggerInfo(AliQA::TASKINDEX_t task);
+ void DisplayTriggerInfo(AliQAv1::TASKINDEX_t task);
Bool_t FillTriggerDCSHistos();
void InitRecPointsTracker();
void InitRecPointsTrigger();
//____________________________________________________________________________
AliMUONQADataMakerSim::AliMUONQADataMakerSim() :
- AliQADataMakerSim(AliQA::GetDetName(AliQA::kMUON), "MUON Quality Assurance Data Maker"),
+ AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kMUON), "MUON Quality Assurance Data Maker"),
fHitStore(0x0),
fDigitStore(0x0)
{
}
//____________________________________________________________________________
-void AliMUONQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray** list)
+void AliMUONQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list)
{
///Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kMUON, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kMUON, task, list) ;
}
/// make SDigits QA from Tree
virtual void MakeDigits(TTree* digitsTree);
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray** list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list);
AliMUONVHitStore* fHitStore; //!< pointer to hit store
AliMUONVDigitStore* fDigitStore; //!< pointer to digit store
class AliGRPObject {};
class AliQA {};
+ class AliQAv1 {};
class AliRunInfo {};
class AliEventInfo {};
MuonRec->SetNumberOfEventsPerFile(1000);
MuonRec->SetOption("MUON",recoptions);
MuonRec->SetRunQA("MUON:ALL");
- MuonRec->SetQAWriteExpert(AliQA::kMUON);
+ MuonRec->SetQAWriteExpert(AliQAv1::kMUON);
// uncomment the following lines if you want to set custom RecoParam
// instead of getting them from the OCDB
// AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
// --- AliRoot header files ---
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliPHOSQAChecker.h"
//____________________________________________________________________________
AliPHOSQADataMakerRec::AliPHOSQADataMakerRec() :
- AliQADataMakerRec(AliQA::GetDetName(AliQA::kPHOS), "PHOS Quality Assurance Data Maker")
+ AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kPHOS), "PHOS Quality Assurance Data Maker")
{
// ctor
}
}
//____________________________________________________________________________
-void AliPHOSQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliPHOSQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
if(GetRawsData(kHGqualMod1) && GetRawsData(kHGmod1))
if(GetRawsData(kHGqualMod5) && GetRawsData(kHGmod5))
GetRawsData(kHGqualMod5)->Divide( GetRawsData(kHGmod5) ) ;
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kPHOS, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kPHOS, task, list) ;
}
//____________________________________________________________________________
}
delete decoder;
GetRawsData(kEtotLG)->Fill(lgEtot) ;
- TParameter<double> * p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kEtotLG)->GetName()))) ;
+ TParameter<double> * p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kEtotLG)->GetName()))) ;
p->SetVal(lgEtot) ;
GetRawsData(kEtotHG)->Fill(hgEtot) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kEtotHG)->GetName()))) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kEtotHG)->GetName()))) ;
p->SetVal(hgEtot) ;
GetRawsData(kNtotLG)->Fill(lgNtot) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kNtotLG)->GetName()))) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kNtotLG)->GetName()))) ;
p->SetVal(lgNtot) ;
GetRawsData(kNtotHG)->Fill(hgNtot) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kNtotHG)->GetName()))) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kNtotHG)->GetName()))) ;
p->SetVal(hgNtot) ;
}
//____________________________________________________________________________
private:
const AliPHOSRecoParam* GetRecoParam() const { return dynamic_cast<const AliPHOSRecoParam *>(fRecoParam); }
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
virtual void InitESDs() ;
virtual void InitRecPoints() ;
virtual void InitRaws() ;
//____________________________________________________________________________
AliPHOSQADataMakerSim::AliPHOSQADataMakerSim() :
- AliQADataMakerSim(AliQA::GetDetName(AliQA::kPHOS), "PHOS Quality Assurance Data Maker"),
+ AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kPHOS), "PHOS Quality Assurance Data Maker"),
fHits(0x0)
{
// ctor
}
//____________________________________________________________________________
-void AliPHOSQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliPHOSQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kPHOS, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kPHOS, task, list) ;
}
//____________________________________________________________________________
virtual ~AliPHOSQADataMakerSim() {;} // dtor
private:
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
virtual void InitHits() ;
virtual void InitDigits() ;
virtual void InitSDigits() ;
/*
// check the QA result for RAWS
- AliQA * qa = AliQA::Instance(AliQA::kPHOS) ;
- if ( qa->IsSet(AliQA::kPHOS, AliQA::kRAW, AliQA::kFATAL)) {
+ AliQAv1 * qa = AliQAv1::Instance(AliQAv1::kPHOS) ;
+ if ( qa->IsSet(AliQAv1::kPHOS, AliQAv1::kRAW, AliQAv1::kFATAL)) {
AliFatal("QA status in RAW was Fatal") ;
- } else if ( qa->IsSet(AliQA::kPHOS, AliQA::kRAW, AliQA::kERROR)) {
+ } else if ( qa->IsSet(AliQAv1::kPHOS, AliQAv1::kRAW, AliQAv1::kERROR)) {
AliError("QA status in RAW was Error") ;
- } else if ( qa->IsSet(AliQA::kPHOS, AliQA::kRAW, AliQA::kWARNING) ) {
+ } else if ( qa->IsSet(AliQAv1::kPHOS, AliQAv1::kRAW, AliQAv1::kWARNING) ) {
AliWarning("QA status in RAW was Warning") ;
- } else if ( qa->IsSet(AliQA::kPHOS, AliQA::kRAW, AliQA::kINFO) ) {
+ } else if ( qa->IsSet(AliQAv1::kPHOS, AliQAv1::kRAW, AliQAv1::kINFO) ) {
AliInfo("QA status in RAW was Info") ;
}
*/
// // make Quality Assurance data
//
// if (GetQADataMaker()->IsCycleDone() ) {
-// GetQADataMaker()->EndOfCycle(AliQA::kHITS) ;
-// GetQADataMaker()->EndOfCycle(AliQA::kSDIGITS) ;
-// GetQADataMaker()->StartOfCycle(AliQA::kHITS) ;
-// GetQADataMaker()->StartOfCycle(AliQA::kSDIGITS, kTRUE) ;
+// GetQADataMaker()->EndOfCycle(AliQAv1::kHITS) ;
+// GetQADataMaker()->EndOfCycle(AliQAv1::kSDIGITS) ;
+// GetQADataMaker()->StartOfCycle(AliQAv1::kHITS) ;
+// GetQADataMaker()->StartOfCycle(AliQAv1::kSDIGITS, kTRUE) ;
// }
-// GetQADataMaker()->Exec(AliQA::kHITS, hits) ;
-// GetQADataMaker()->Exec(AliQA::kSDIGITS, sdigits) ;
+// GetQADataMaker()->Exec(AliQAv1::kHITS, hits) ;
+// GetQADataMaker()->Exec(AliQAv1::kSDIGITS, sdigits) ;
// GetQADataMaker()->Increment() ;
//Now write SDigits
}// event loop
// //Write the quality assurance data
-// GetQADataMaker()->EndOfCycle(AliQA::kHITS) ;
-// GetQADataMaker()->EndOfCycle(AliQA::kSDIGITS) ;
+// GetQADataMaker()->EndOfCycle(AliQAv1::kHITS) ;
+// GetQADataMaker()->EndOfCycle(AliQAv1::kSDIGITS) ;
// GetQADataMaker()->Finish() ;
Unload();
// --- AliRoot header files ---
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliPMDQAChecker.h"
//____________________________________________________________________________
AliPMDQADataMakerRec::AliPMDQADataMakerRec() :
- AliQADataMakerRec(AliQA::GetDetName(AliQA::kPMD), "PMD Quality Assurance Data Maker")
+ AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kPMD), "PMD Quality Assurance Data Maker")
{
// ctor
}
}
//____________________________________________________________________________
-void AliPMDQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliPMDQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kPMD, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kPMD, task, list) ;
}
virtual void MakeRecPoints(TTree * recpoTree) ;
virtual void MakeESDs(AliESDEvent * esd) ;
virtual void StartOfDetectorCycle() ;
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
ClassDef(AliPMDQADataMakerRec,1) // description
//____________________________________________________________________________
AliPMDQADataMakerSim::AliPMDQADataMakerSim() :
- AliQADataMakerSim(AliQA::GetDetName(AliQA::kPMD), "PMD Quality Assurance Data Maker")
+ AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kPMD), "PMD Quality Assurance Data Maker")
{
// ctor
}
}
//____________________________________________________________________________
-void AliPMDQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliPMDQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kPMD, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kPMD, task, list) ;
}
virtual void MakeDigits(TClonesArray * digits) ;
virtual void MakeDigits(TTree * digitTree) ;
virtual void StartOfDetectorCycle() ;
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
ClassDef(AliPMDQADataMakerSim,1) // description
// --- AliRoot header files ---
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliCorrQAChecker.h"
ClassImp(AliCorrQAChecker)
//__________________________________________________________________
-Double_t * AliCorrQAChecker::Check(AliQA::ALITASK_t index, TNtupleD ** nData)
+Double_t * AliCorrQAChecker::Check(AliQAv1::ALITASK_t index, TNtupleD ** nData)
{
// check the QA of correlated data stored in a ntuple
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
test[specie] = 0. ;
- if ( index != AliQA::kRAW ) {
+ if ( index != AliQAv1::kRAW ) {
AliWarning("Checker not implemented") ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
test[specie] = 1. ;
AliCorrQAChecker(const AliCorrQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()) {;} // cpy ctor
virtual ~AliCorrQAChecker() {;} // dtor
- virtual Double_t * Check(AliQA::ALITASK_t index) { return AliQACheckerBase::Check(index) ;}
- virtual Double_t * Check(AliQA::ALITASK_t index, TObjArray ** obj) { return AliQACheckerBase::Check(index, obj) ;}
- Double_t * Check(AliQA::ALITASK_t index, TNtupleD ** nData) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t index) { return AliQACheckerBase::Check(index) ;}
+ virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** obj) { return AliQACheckerBase::Check(index, obj) ;}
+ Double_t * Check(AliQAv1::ALITASK_t index, TNtupleD ** nData) ;
private:
//____________________________________________________________________________
AliCorrQADataMakerRec::AliCorrQADataMakerRec(AliQADataMaker ** qadm ) :
-AliQADataMakerRec(AliQA::GetDetName(AliQA::kCORR), "Corr Quality Assurance Data Maker"),
+AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kCORR), "Corr Quality Assurance Data Maker"),
fMaxRawVar(0),
fqadm(qadm)
{
}
//____________________________________________________________________________
-void AliCorrQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** /*list*/)
+void AliCorrQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** /*list*/)
{
//Detector specific actions at end of cycle
// do the QA checking
- if (task == AliQA::kRAWS) {
- AliQAChecker::Instance()->Run(AliQA::kCORR, task, fCorrNt) ;
+ if (task == AliQAv1::kRAWS) {
+ AliQAChecker::Instance()->Run(AliQAv1::kCORR, task, fCorrNt) ;
}
}
delete fRawsQAList ; // not needed for the time being
fRawsQAList = NULL ;
TString varlist("") ;
- for ( Int_t detIndex = 0 ; detIndex < AliQA::kNDET ; detIndex++ ) {
+ for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++ ) {
AliQADataMaker * qadm = fqadm[detIndex] ;
if ( ! qadm )
continue ;
AliWarning("NTUPLE not created") ;
} else {
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- char * name = Form("%s_%s", AliQA::GetQACorrName(), AliRecoParam::GetEventSpecieName(specie)) ;
+ char * name = Form("%s_%s", AliQAv1::GetQACorrName(), AliRecoParam::GetEventSpecieName(specie)) ;
fCorrNt[specie] = new TNtupleD(name, "Raws data correlation among detectors", varlist.Data()) ;
}
}
const Int_t kSize = fMaxRawVar ;
Double_t *varvalue = new Double_t[kSize] ;
Int_t index = 0 ;
- for ( Int_t detIndex = 0 ; detIndex < AliQA::kNDET ; detIndex++ ) {
+ for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++ ) {
AliQADataMaker * qadm = fqadm[detIndex] ;
if ( ! qadm )
continue ;
private:
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
virtual void InitESDs() ;
virtual void InitRecPoints() ;
virtual void InitRaws() ;
// --- AliRoot header files ---
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliGlobalQAChecker.h"
ClassImp(AliGlobalQADataMaker)
//____________________________________________________________________________
-void AliGlobalQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliGlobalQADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kGLOBAL, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kGLOBAL, task, list) ;
}
//____________________________________________________________________________
AliQADataMakerRec(qadm) {;}
private:
- void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+ void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
void InitRaws();
void InitRecPoints();
ClassImp(AliQA)
AliQA * AliQA::fgQA = 0x0 ;
TFile * AliQA::fgQADataFile = 0x0 ;
-TString AliQA::fgQADataFileName = "QA" ; // will transform into Det.QA.run.root
+TString AliQA::fgQADataFileName = "QA" ; // will transform into Det.QA.run.cycle.root
TFile * AliQA::fgQARefFile = 0x0 ;
TString AliQA::fgQARefDirName = "" ;
TString AliQA::fgQARefFileName = "QA.root" ;
TString AliQA::fgDetNames[] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD",
"ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT", "Global", "CORR"} ;
TString AliQA::fgGRPPath = "GRP/GRP/Data" ;
+TString AliQA::fgRTNames[] = {"UNKNOWN", "AUTO_TEST", "CALIBRATION", "CALIBRATION_PULSER", "CHANNEL_DELAY_TUNING", "COSMIC",
+ "COSMICS", "DAQ_FO_UNIF_SCAN", "DAQ_GEN_DAC_SCAN", "DAQ_MEAN_TH_SCAN", "DAQ_MIN_TH_SCAN",
+ "DAQ_NOISY_PIX_SCAN", "DAQ_PIX_DELAY_SCAN", "DAQ_UNIFORMITY_SCAN", "DCS_FO_UNIF_SCAN",
+ "DCS_MEAN_TH_SCAN", "DCS_MIN_TH_SCAN", "DCS_PIX_DELAY_SCAN", "DCS_UNIFORMITY_SCAN",
+ "DDL_TEST", "GAIN", "PEDESTAL", "INJECTOR", "LASER", "MONTECARLO", "NOISE", "NOISY_PIX_SCAN",
+ "PHYSICS", "PULSER", "STANDALONE", "STANDALONE_BC", "STANDALONE_CENTRAL", "STANDALONE_COSMIC",
+ "STANDALONE_EMD", "STANDALONE_LASER", "STANDALONE_MB", "STANDALONE_PEDESTAL",
+ "STANDALONE_SEMICENTRAL", "STANDALONE_PULSER" } ;
TString AliQA::fgTaskNames[] = {"Raws", "Hits", "SDigits", "Digits", "RecPoints", "TrackSegments", "RecParticles", "ESDs"} ;
-const TString AliQA::fgkLabLocalFile = "file://" ;
-const TString AliQA::fgkLabLocalOCDB = "local://" ;
-const TString AliQA::fgkLabAliEnOCDB = "alien://" ;
-const TString AliQA::fgkRefFileName = "QA.root" ;
-const TString AliQA::fgkQAName = "QA" ;
-const TString AliQA::fgkQACorrNtName = "CorrQA" ;
-const TString AliQA::fgkRefOCDBDirName = "QA" ;
-TString AliQA::fgRefDataDirName = "" ;
-const TString AliQA::fgkQARefOCDBDefault = "alien://folder=/alice/QA/20" ;
-const TString AliQA::fgkExpert = "Expert" ;
-const UInt_t AliQA::fgkExpertBit = 16 ;
-const UInt_t AliQA::fgkQABit = 17 ;
+const TString AliQA::fkgLabLocalFile = "file://" ;
+const TString AliQA::fkgLabLocalOCDB = "local://" ;
+const TString AliQA::fkgLabAliEnOCDB = "alien://" ;
+const TString AliQA::fkgRefFileName = "QA.root" ;
+const TString AliQA::fkgQAName = "QA" ;
+const TString AliQA::fkgQACorrNtName = "CorrQA" ;
+const TString AliQA::fkgRefOCDBDirName = "Ref" ;
+TString AliQA::fkgRefDataDirName = "" ;
+const TString AliQA::fkgQARefOCDBDefault = "alien://folder=/alice/QA/20" ;
+const TString AliQA::fkgExpert = "Expert" ;
+const UInt_t AliQA::fkgExpertBit = 16 ;
+const UInt_t AliQA::fkgQABit = 17 ;
//____________________________________________________________________________
AliQA::AliQA() :
TNamed("", ""),
fNdet(kNDET),
- fNEventSpecies(AliRecoParam::kNSpecies),
- fLengthQA(fNdet*fNEventSpecies),
- fQA(new ULong_t[fLengthQA]),
+ fQA(new ULong_t[fNdet]),
fDet(kNULLDET),
- fTask(kNULLTASK),
- fEventSpecie(AliRecoParam::kDefault),
- fEventSpecies(new Bool_t[fNEventSpecies])
+ fTask(kNULLTASK)
+
{
// default constructor
- memset(fQA,0,fLengthQA*sizeof(ULong_t));
- memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+ // beware singleton: not to be used
+
+ for (Int_t index = 0 ; index < fNdet ; index++)
+ fQA[index] = 0 ;
}
//____________________________________________________________________________
AliQA::AliQA(const AliQA& qa) :
TNamed(qa),
fNdet(qa.fNdet),
- fNEventSpecies(qa.fNEventSpecies),
- fLengthQA(qa.fLengthQA),
- fQA(new ULong_t[fLengthQA]),
+ fQA(qa.fQA),
fDet(qa.fDet),
- fTask(qa.fTask),
- fEventSpecie(qa.fEventSpecie),
- fEventSpecies(new Bool_t[fNEventSpecies])
+ fTask(qa.fTask)
{
// cpy ctor
- memcpy(fQA,qa.fQA,fLengthQA*sizeof(ULong_t));
- memcpy(fEventSpecies,qa.fEventSpecies,fNEventSpecies*sizeof(Bool_t));
}
//_____________________________________________________________________________
AliQA& AliQA::operator = (const AliQA& qa)
{
- // assignment operator
- if(&qa != this) {
- TNamed::operator=(qa);
- fNdet = qa.fNdet;
- fNEventSpecies = qa.fNEventSpecies;
- fLengthQA = qa.fLengthQA;
-
- if(fQA) delete [] fQA;
- fQA = new ULong_t[fLengthQA];
- memcpy(fQA,qa.fQA,fLengthQA*sizeof(ULong_t));
-
- fDet = qa.fDet;
- fTask = qa.fTask;
- fEventSpecie = qa.fEventSpecie;
- if(fEventSpecies) delete [] fEventSpecies;
- fEventSpecies = new Bool_t[fNEventSpecies];
- memcpy(fEventSpecies,qa.fEventSpecies,fNEventSpecies*sizeof(Bool_t));
- }
- return *this;
-}
+// assignment operator
-//_______________________________________________________________
-AliQA::AliQA(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es) :
-TNamed("QA", "Quality Assurance status"),
-fNdet(kNDET),
-fNEventSpecies(eslength),
-fLengthQA(qalength),
-fQA(new ULong_t[fLengthQA]),
-fDet(kNULLDET),
-fTask(kNULLTASK),
-fEventSpecie(AliRecoParam::kDefault),
-fEventSpecies(new Bool_t[fNEventSpecies])
-{
- // constructor to be used
- memcpy(fQA, qa, fLengthQA*sizeof(ULong_t));
- memcpy(fEventSpecies, es, fNEventSpecies*sizeof(Bool_t));
+ this->~AliQA();
+ new(this) AliQA(qa);
+ return *this;
}
//_______________________________________________________________
AliQA::AliQA(const DETECTORINDEX_t det) :
TNamed("QA", "Quality Assurance status"),
- fNdet(kNDET),
- fNEventSpecies(AliRecoParam::kNSpecies),
- fLengthQA(fNdet*fNEventSpecies),
- fQA(new ULong_t[fLengthQA]),
+ fNdet(kNDET),
+ fQA(new ULong_t[fNdet]),
fDet(det),
- fTask(kNULLTASK),
- fEventSpecie(AliRecoParam::kDefault),
- fEventSpecies(new Bool_t[fNEventSpecies])
+ fTask(kNULLTASK)
{
// constructor to be used
- if (! CheckRange(det) ) fDet = kNULLDET ;
- memset(fQA,0,fLengthQA*sizeof(ULong_t));
- memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+ if (! CheckRange(det) ) {
+ fDet = kNULLDET ;
+ return ;
+ }
+ Int_t index ;
+ for (index = 0; index < fNdet; index++)
+ fQA[index] = 0 ;
}
//_______________________________________________________________
AliQA::AliQA(const ALITASK_t tsk) :
- TNamed("QA", "Quality Assurance status"),
- fNdet(kNDET),
- fNEventSpecies(AliRecoParam::kNSpecies),
- fLengthQA(fNdet*fNEventSpecies),
- fQA(new ULong_t[fLengthQA]),
+ TNamed("QA", "Quality Assurance status"),
+ fNdet(kNDET),
+ fQA(new ULong_t[fNdet]),
fDet(kNULLDET),
- fTask(tsk),
- fEventSpecie(AliRecoParam::kDefault),
- fEventSpecies(new Bool_t[fNEventSpecies])
+ fTask(tsk)
{
// constructor to be used in the AliRoot module (SIM, REC, ESD or ANA)
- if (! CheckRange(tsk) ) fTask = kNULLTASK ;
- memset(fQA,0,fLengthQA*sizeof(ULong_t));
- memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+ if (! CheckRange(tsk) ) {
+ fTask = kNULLTASK ;
+ return ;
+ }
+ Int_t index ;
+ for (index = 0; index < fNdet; index++)
+ fQA[index] = 0 ;
}
//____________________________________________________________________________
AliQA::~AliQA()
{
// dtor
- delete [] fQA;
- delete [] fEventSpecies;
+ delete[] fQA ;
}
//_______________________________________________________________
Bool_t rv = kFALSE ;
Int_t index ;
for (index = 0; index < kNDET ; index++)
- rv = rv || IsSet(DETECTORINDEX_t(index), fTask, fEventSpecie, kFATAL) ;
+ rv = rv || IsSet(DETECTORINDEX_t(index), fTask, kFATAL) ;
return rv ;
}
return rv ;
}
-//_______________________________________________________________
-Bool_t AliQA::CheckRange(AliRecoParam::EventSpecie_t es) const
-{
- // check if bit is in given bit range: 0-kNBit
- Bool_t rv = kFALSE ;
- switch (es) {
- case AliRecoParam::kDefault:
- rv = kTRUE ;
- break ;
- case AliRecoParam::kLowMult:
- rv = kTRUE ;
- break ;
- case AliRecoParam::kHighMult:
- rv = kTRUE ;
- break ;
- case AliRecoParam::kCosmic:
- rv = kTRUE ;
- break ;
- case AliRecoParam::kCalib:
- rv = kTRUE ;
- break ;
- }
- if (!rv)
- AliFatal(Form("Event Specie %d is not valid", es)) ;
- return rv ;
-}
+
//_______________________________________________________________
-const char * AliQA::GetAliTaskName(ALITASK_t tsk)
+char * AliQA::GetAliTaskName(ALITASK_t tsk)
{
// returns the char name corresponding to module index
TString tskName ;
tsk = kNULLTASK ;
break ;
}
- return tskName.Data() ;
+ return Form("%s", tskName.Data()) ;
}
//_______________________________________________________________
-const char * AliQA::GetBitName(QABIT_t bit) const
+char * AliQA::GetBitName(QABIT_t bit) const
{
// returns the char name corresponding to bit
TString bitName ;
bit = kNULLBit ;
break ;
}
- return bitName.Data() ;
+ return Form("%s", bitName.Data()) ;
}
//_______________________________________________________________
}
//_______________________________________________________________
-TFile * AliQA::GetQADataFile(const char * name, Int_t run)
+TFile * AliQA::GetQADataFile(const char * name, const Int_t run)
{
// opens the file to store the detectors Quality Assurance Data Maker results
const char * temp = Form("%s.%s.%d.root", name, fgQADataFileName.Data(), run) ;
fgQAResultFile = 0x0 ;
// if (!fgQAResultFile) {
TString dirName(fgQAResultDirName) ;
- if ( dirName.Contains(fgkLabLocalFile))
- dirName.ReplaceAll(fgkLabLocalFile, "") ;
+ if ( dirName.Contains(fkgLabLocalFile))
+ dirName.ReplaceAll(fkgLabLocalFile, "") ;
TString fileName(dirName + fgQAResultFileName) ;
TString opt("") ;
if ( !gSystem->AccessPathName(fileName) )
return fgQAResultFile ;
}
+//_______________________________________________________________
+const TString AliQA::GetRunTypeName(RUNTYPE_t rt)
+{
+ TString rv("Invalid Run Type") ;
+ if ( rt == kNULLTYPE ) {
+ rv = "Known RUN_TYPE are: \n" ;
+ for (Int_t index = 0 ; index < kNTYPE; index++) {
+ rv += Form("%2d -- %s\n", index, fgRTNames[index].Data()) ;
+ }
+ printf("%s", rv.Data()) ;
+ return "" ;
+ }
+ else {
+ if ( rt > kNULLTYPE && rt < kNTYPE )
+ rv = fgRTNames[rt] ;
+ }
+ return rv ;
+}
+
//_______________________________________________________________
AliQA::TASKINDEX_t AliQA::GetTaskIndex(const char * name)
{
}
//_______________________________________________________________
-Bool_t AliQA::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, Int_t ies, QABIT_t bit) const
-{
- // Checks is the requested bit is set
-
- const AliRecoParam::EventSpecie_t es = AliRecoParam::Convert(ies) ;
- return IsSet(det, tsk, es, bit) ;
-
-}
-
-//_______________________________________________________________
-Bool_t AliQA::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) const
+Bool_t AliQA::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit) const
{
// Checks is the requested bit is set
CheckRange(det) ;
CheckRange(tsk) ;
CheckRange(bit) ;
- CheckRange(es) ;
ULong_t offset = Offset(tsk) ;
- ULong_t status = GetStatus(det, es) ;
+ ULong_t status = GetStatus(det) ;
offset+= bit ;
status = (status & 1 << offset) != 0 ;
return status ;
}
//_______________________________________________________________
-Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) const
+Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk) const
{
// Checks is the requested bit is set
CheckRange(det) ;
CheckRange(tsk) ;
- CheckRange(es) ;
ULong_t offset = Offset(tsk) ;
- ULong_t status = GetStatus(det, es) ;
- ULong_t st = 0 ;
+ ULong_t status = GetStatus(det) ;
+ UShort_t st = 0 ;
for ( Int_t bit = 0 ; bit < kNBIT ; bit++) {
offset+= bit ;
st += (status & 1 << offset) != 0 ;
return kTRUE ;
}
//_______________________________________________________________
-Bool_t AliQA::IsSetAny(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es) const
+Bool_t AliQA::IsSetAny(DETECTORINDEX_t det) const
{
// Checks is the requested bit is set
CheckRange(det) ;
- CheckRange(es) ;
- ULong_t status = GetStatus(det, es) ;
- ULong_t st = 0 ;
+ ULong_t status = GetStatus(det) ;
+ UShort_t st = 0 ;
for ( Int_t tsk = 0 ; tsk < kNTASK ; tsk++) {
ULong_t offset = Offset(ALITASK_t(tsk)) ;
for ( Int_t bit = 0 ; bit < kNBIT ; bit++) {
//_______________________________________________________________
AliQA * AliQA::Instance()
{
- // Get an instance of the singleton. The only authorized way to call the ctor
+ // Get an instance of the singleton.
+ // Object must have been instantiated with Instance(ALITASK) first
- if ( ! fgQA) {
- TFile * f = GetQAResultFile() ;
- fgQA = dynamic_cast<AliQA *>(f->Get("QA")) ;
- if ( ! fgQA )
- fgQA = new AliQA() ;
- }
- return fgQA ;
-}
-
-//_______________________________________________________________
-AliQA * AliQA::Instance(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es)
-{
- // Get an instance of the singleton. The only authorized way to call the ctor
-
- if ( ! fgQA)
- fgQA = new AliQA(qalength, qa, eslength, es) ;
return fgQA ;
}
//_______________________________________________________________
AliQA * AliQA::Instance(const ALITASK_t tsk)
{
- // Get an instance of the singleton. The only authorized way to call the ctor
+ // get an instance of the singleton.
if ( ! fgQA)
switch (tsk) {
TIter next(list) ;
AliQA * qa ;
while ( (qa = (AliQA*)next() ) ) {
- for (Int_t es = 0 ; es < fNEventSpecies ; es++) {
- if (qa->IsSet(DETECTORINDEX_t(det), ALITASK_t(task), es, QABIT_t(bit)))
- Set(QABIT_t(bit), es) ;
- }
+ qa->IsSet(DETECTORINDEX_t(det), ALITASK_t(task), QABIT_t(bit)) ;
+ Set(QABIT_t(bit)) ;
} // qa list
} // bit
} // task
}
//_______________________________________________________________
-void AliQA::ResetStatus(DETECTORINDEX_t det)
-{
- // reset the status of det for all event specie
- for (Int_t es = 0 ; es < fNEventSpecies ; es++)
- fQA[det*fNdet+es] = 0 ;
-}
-
-//_______________________________________________________________
-void AliQA::Set(QABIT_t bit, Int_t ies)
+void AliQA::Set(QABIT_t bit)
{
- // Set the status bit of the current detector in the current module and for the current event specie
- Set(bit, AliRecoParam::Convert(ies)) ;
-}
-
-//_______________________________________________________________
-void AliQA::Set(QABIT_t bit, AliRecoParam::EventSpecie_t es)
-{
- // Set the status bit of the current detector in the current module and for the current event specie
+ // Set the status bit of the current detector in the current module
- SetStatusBit(fDet, fTask, es, bit) ;
+ SetStatusBit(fDet, fTask, bit) ;
}
//_____________________________________________________________________________
// Set the root directory where the QA reference data are stored
fgQARefDirName = name ;
- if ( fgQARefDirName.Contains(fgkLabLocalFile) )
- fgQARefFileName = fgkRefFileName ;
- else if ( fgQARefDirName.Contains(fgkLabLocalOCDB) )
- fgQARefFileName = fgkQAName ;
- else if ( fgQARefDirName.Contains(fgkLabAliEnOCDB) )
- fgQARefFileName = fgkQAName ;
+ if ( fgQARefDirName.Contains(fkgLabLocalFile) )
+ fgQARefFileName = fkgRefFileName ;
+ else if ( fgQARefDirName.Contains(fkgLabLocalOCDB) )
+ fgQARefFileName = fkgQAName ;
+ else if ( fgQARefDirName.Contains(fkgLabAliEnOCDB) )
+ fgQARefFileName = fkgQAName ;
else {
printf("ERROR: %s is an invalid storage definition\n", name) ;
printf("AliQA::SetQARefDir: QA references are in %s\n", tmp.Data() ) ;
}
+//_____________________________________________________________________________
+void AliQA::SetQARefDataDirName(const char * name)
+{
+ // Set the lower level directory name where reference data are found
+ TString test(name) ;
+ RUNTYPE_t rt = kNULLTYPE ;
+ for (Int_t index = 0; index < kNTYPE; index++) {
+ if (test.CompareTo(fgRTNames[index]) == 0) {
+ rt = (RUNTYPE_t) index ;
+ break ;
+ }
+ }
+
+ if (rt == kNULLTYPE) {
+ printf("AliQA::SetQARefDataDirName: %s is an unknown RUN TYPE name\n", name) ;
+ return ;
+ }
+
+ SetQARefDataDirName(rt) ;
+}
+
//_____________________________________________________________________________
void AliQA::SetQAResultDirName(const char * name)
{
fgQAResultDirName.Prepend(name) ;
printf("AliQA::SetQAResultDirName: QA results are in %s\n", fgQAResultDirName.Data()) ;
- if ( fgQAResultDirName.Contains(fgkLabLocalFile))
- fgQAResultDirName.ReplaceAll(fgkLabLocalFile, "") ;
+ if ( fgQAResultDirName.Contains(fkgLabLocalFile))
+ fgQAResultDirName.ReplaceAll(fkgLabLocalFile, "") ;
fgQAResultFileName.Prepend(fgQAResultDirName) ;
}
//_______________________________________________________________
-void AliQA::SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit)
+void AliQA::SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit)
{
// Set the status bit for a given detector and a given task
CheckRange(det) ;
CheckRange(tsk) ;
CheckRange(bit) ;
- CheckRange(es) ;
ULong_t offset = Offset(tsk) ;
- ULong_t status = GetStatus(det, es) ;
+ ULong_t status = GetStatus(det) ;
offset+= bit ;
status = status | 1 << offset ;
- SetStatus(det, es, status) ;
+ SetStatus(det, status) ;
}
//_______________________________________________________________
-void AliQA::Show(DETECTORINDEX_t det) const
-{
- // dispplay the QA status word
- if ( det == kNULLDET)
- det = fDet ;
- for (Int_t ies = 0 ; ies < fNEventSpecies ; ies++) {
- const Bool_t what = IsEventSpecieSet(ies) ;
- if ( what )
- ShowStatus(det, kNULLTASK, AliRecoParam::Convert(ies)) ;
- }
-}
-
-//_______________________________________________________________
-void AliQA::ShowAll() const
+void AliQA::ShowAll() const
{
// dispplay the QA status word
Int_t index ;
for (index = 0 ; index < kNDET ; index++) {
for (Int_t tsk = kRAW ; tsk < kNTASK ; tsk++) {
- for (Int_t ies = 0 ; ies < fNEventSpecies ; ies++) {
- const Bool_t what = IsEventSpecieSet(ies) ;
- if ( what )
- ShowStatus(DETECTORINDEX_t(index), ALITASK_t(tsk), AliRecoParam::Convert(ies)) ;
- }
- }
+ ShowStatus(DETECTORINDEX_t(index), ALITASK_t(tsk)) ;
+ }
}
}
//_______________________________________________________________
-void AliQA::ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) const
+void AliQA::ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk) const
{
// Prints the full QA status of a given detector
CheckRange(det) ;
- CheckRange(es) ;
- ULong_t status = GetStatus(det, es) ;
+ ULong_t status = GetStatus(det) ;
ULong_t tskStatus[kNTASK] ;
tskStatus[kRAW] = status & 0x0000f ;
tskStatus[kSIM] = status & 0x000f0 ;
tskStatus[kESD] = status & 0x0f000 ;
tskStatus[kANA] = status & 0xf0000 ;
- AliInfo(Form("====> QA Status for %8s %8s raw =0x%x, sim=0x%x, rec=0x%x, esd=0x%x, ana=0x%x", GetDetName(det).Data(), AliRecoParam::GetEventSpecieName(es),
+ AliInfo(Form("====> QA Status for %8s raw =0x%x, sim=0x%x, rec=0x%x, esd=0x%x, ana=0x%x", GetDetName(det).Data(),
tskStatus[kRAW], tskStatus[kSIM], tskStatus[kREC], tskStatus[kESD], tskStatus[kANA] )) ;
if (tsk == kNULLTASK) {
for (Int_t itsk = kRAW ; itsk < kNTASK ; itsk++) {
- ShowASCIIStatus(es, det, ALITASK_t(itsk), tskStatus[itsk]) ;
+ ShowASCIIStatus(det, ALITASK_t(itsk), tskStatus[itsk]) ;
}
} else {
- ShowASCIIStatus(es, det, tsk, tskStatus[tsk]) ;
+ ShowASCIIStatus(det, tsk, tskStatus[tsk]) ;
}
}
//_______________________________________________________________
-void AliQA::ShowASCIIStatus(AliRecoParam::EventSpecie_t es, DETECTORINDEX_t det, ALITASK_t tsk, const ULong_t status) const
+void AliQA::ShowASCIIStatus(DETECTORINDEX_t det, ALITASK_t tsk, const ULong_t status) const
{
// print the QA status in human readable format
TString text;
for (Int_t bit = kINFO ; bit < kNBIT ; bit++) {
- if (IsSet(det, tsk, es, QABIT_t(bit))) {
+ if (IsSet(det, tsk, QABIT_t(bit))) {
text = GetBitName(QABIT_t(bit)) ;
text += " " ;
}
}
if (! text.IsNull())
- printf(" %8s %8s %4s 0x%4lx, Problem signalled: %8s \n", AliRecoParam::GetEventSpecieName(es), GetDetName(det).Data(), GetAliTaskName(tsk), status, text.Data()) ;
+ printf(" %8s %4s 0x%4lx, Problem signalled: %8s \n", GetDetName(det).Data(), GetAliTaskName(tsk), status, text.Data()) ;
}
//_______________________________________________________________
-void AliQA::UnSet(QABIT_t bit, Int_t ies)
-{
- // UnSet the status bit of the current detector in the current module
- UnSet(bit, AliRecoParam::Convert(ies)) ;
-}
-
-//_______________________________________________________________
-void AliQA::UnSet(QABIT_t bit, AliRecoParam::EventSpecie_t es)
+void AliQA::UnSet(QABIT_t bit)
{
// UnSet the status bit of the current detector in the current module
- UnSetStatusBit(fDet, fTask, es, bit) ;
+ UnSetStatusBit(fDet, fTask, bit) ;
}
//_______________________________________________________________
-void AliQA::UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit)
+void AliQA::UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit)
{
// UnSet the status bit for a given detector and a given task
CheckRange(det) ;
CheckRange(tsk) ;
CheckRange(bit) ;
- CheckRange(es) ;
ULong_t offset = Offset(tsk) ;
- ULong_t status = GetStatus(det, es) ;
+ ULong_t status = GetStatus(det) ;
offset+= bit ;
status = status & 0 << offset ;
- SetStatus(det, es, status) ;
-}
+ SetStatus(det, status) ;
+}
\ No newline at end of file
#ifndef ALIQA_H
#define ALIQA_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice */
+* See cxx source for full Copyright notice */
/* $Id$ */
//
#include <TNamed.h>
-#include <TMath.h>
class TFile ;
#include "AliLog.h"
-#include "AliRecoParam.h"
class AliQA : public TNamed {
public:
- enum DETECTORINDEX_t {
+ enum DETECTORINDEX_t {
kNULLDET=-1, kITS, kTPC, kTRD, kTOF, kPHOS, kHMPID, kEMCAL, kMUON, kFMD,
kZDC, kPMD, kT0, kVZERO, kACORDE, kHLT, kGLOBAL, kCORR, kNDET};
- enum ALITASK_t {
+ enum ALITASK_t {
kNULLTASK=-1, kRAW, kSIM, kREC, kESD, kANA, kNTASK };
- enum QABIT_t {
+ enum QABIT_t {
kNULLBit=-1, kINFO, kWARNING, kERROR, kFATAL, kNBIT };
- enum TASKINDEX_t {
+ enum RUNTYPE_t {
+ kNULLTYPE=-1, kUNKOWN, kAUTO_TEST, kCALIBRATION, kCALIBRATION_PULSER, kCHANNEL_DELAY_TUNING, kCOSMIC, kCOSMICS, kDAQ_FO_UNIF_SCAN,
+ kDAQ_GEN_DAC_SCAN, kDAQ_MEAN_TH_SCAN, kDAQ_MIN_TH_SCAN, kDAQ_NOISY_PIX_SCAN, kDAQ_PIX_DELAY_SCAN, kDAQ_UNIFORMITY_SCAN,
+ kDCS_FO_UNIF_SCAN, kDCS_MEAN_TH_SCAN, kDCS_MIN_TH_SCAN, kDCS_PIX_DELAY_SCAN, kDCS_UNIFORMITY_SCAN, kDDL_TEST, kGAIN,
+ kPEDESTAL, kINJECTOR, kLASER, kMONTECARLO, kNOISE, kNOISY_PIX_SCAN, kPHYSICS, kPULSER, kSTANDALONE, kSTANDALONE_BC,
+ kSTANDALONE_CENTRAL, kSTANDALONE_COSMIC, kSTANDALONE_EMD, kSTANDALONE_LASER, kSTANDALONE_MB, kSTANDALONE_PEDESTAL,
+ kSTANDALONE_SEMICENTRAL, kSTANDALONE_PULSER, kNTYPE};
+
+ enum TASKINDEX_t {
kNULLTASKINDEX=-1, kRAWS, kHITS, kSDIGITS, kDIGITS, kRECPOINTS, kTRACKSEGMENTS, kRECPARTICLES, kESDS, kNTASKINDEX };
- // Creators - destructors
- AliQA(); // beware singleton, not to be used
- AliQA(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es) ;
- AliQA(const ALITASK_t tsk) ;
- AliQA(const DETECTORINDEX_t det) ;
- AliQA(const AliQA& qa) ;
- AliQA& operator = (const AliQA& qa) ;
- virtual ~AliQA();
+ // Creators - destructors
+ AliQA(); // beware singleton, not to be used
+ AliQA(const ALITASK_t tsk) ;
+ AliQA(const DETECTORINDEX_t det) ;
+ AliQA(const AliQA& qa) ;
+ AliQA& operator = (const AliQA& qa) ;
+ virtual ~AliQA();
- static AliQA * Instance() ;
- static AliQA * Instance(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es) ;
- static AliQA * Instance(const DETECTORINDEX_t det) ;
- static AliQA * Instance(const ALITASK_t tsk) ;
- static AliQA * Instance(const TASKINDEX_t tsk) ;
+ static AliQA * Instance() ;
+ static AliQA * Instance(const DETECTORINDEX_t det) ;
+ static AliQA * Instance(const ALITASK_t tsk) ;
+ static AliQA * Instance(const TASKINDEX_t tsk) ;
Bool_t CheckFatal() const ;
- static void Close() ;
- static const char * GetAliTaskName(ALITASK_t tsk) ;
- Bool_t * GetEventSpecies() { return fEventSpecies ; }
- static const TString GetExpert() { return fgkExpert ; }
- static UInt_t GetExpertBit() { return fgkExpertBit ; }
- static const TString GetLabLocalFile() { return fgkLabLocalFile ; }
- static const TString GetLabLocalOCDB() { return fgkLabLocalOCDB ; }
- static const TString GetLabAliEnOCDB() { return fgkLabAliEnOCDB ; }
- static DETECTORINDEX_t GetDetIndex(const char * name) ;
- static const TString GetDetName(DETECTORINDEX_t det) { return fgDetNames[det] ; }
- static const char * GetDetName(Int_t det) ;
- static const TString GetGRPPath() { return fgGRPPath ; }
- ULong_t * GetQA() { return fQA ; }
- static UInt_t GetQABit() { return fgkQABit ; }
- static TFile * GetQADataFile(const char * name, Int_t run) ;
- static TFile * GetQADataFile(const char * fileName) ;
- static const char * GetQADataFileName(const char * name, Int_t run)
- {return Form("%s.%s.%d.root", name, fgQADataFileName.Data(), run) ; }
- static const char * GetQADataFileName() { return fgQADataFileName.Data() ; }
- static const char * GetQAName() { return fgkQAName ; }
- static const char * GetQACorrName() { return fgkQACorrNtName ; }
- static TFile * GetQAResultFile() ;
- static const char * GetQAResultFileName() { return (fgQAResultDirName + fgQAResultFileName).Data() ; }
- static const char * GetQARefDefaultStorage() { return fgkQARefOCDBDefault.Data() ; }
- static const char * GetQARefFileName() { return fgQARefFileName ; }
- static const char * GetQARefStorage() { return fgQARefDirName.Data() ; }
- static const char * GetRefOCDBDirName() { return fgkRefOCDBDirName.Data() ; }
- static const char * GetRefDataDirName() { return fgRefDataDirName.Data() ; }
- static TASKINDEX_t GetTaskIndex(const char * name) ;
- static TString GetTaskName(UInt_t tsk) { return fgTaskNames[tsk] ; }
- Bool_t IsEventSpecieSet(AliRecoParam::EventSpecie_t es) const
- {Int_t ibit=0; while(es!=1<<ibit) ++ibit; return fEventSpecies[ibit];}
- Bool_t IsEventSpecieSet(Int_t es) const { return fEventSpecies[es] ; }
- Bool_t IsSet(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) const ;
- Bool_t IsSet(DETECTORINDEX_t det, ALITASK_t tsk, Int_t es, QABIT_t bit) const ;
- Bool_t IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) const ;
- Bool_t IsSetAny(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es) const ;
- void Merge(TCollection * list) ;
- void Set(QABIT_t bit, AliRecoParam::EventSpecie_t es) ;
- void Set(QABIT_t bit, Int_t es) ;
- void SetEventSpecie(AliRecoParam::EventSpecie_t es)
- {Int_t ibit=0; while(es!=1<<ibit) ++ibit; fEventSpecies[ibit] = kTRUE ; }
- static void SetQAResultDirName(const char * name) ;
- static void SetQARefStorage(const char * name) ;
- static void SetQARefDataDirName(AliRecoParam::EventSpecie_t es) { fgRefDataDirName = AliRecoParam::GetEventSpecieName(es) ; }
- static void SetQARefDataDirName(Int_t es) { fgRefDataDirName = AliRecoParam::GetEventSpecieName(es) ; }
- void Show(DETECTORINDEX_t det = kNULLDET) const ;
- void ShowAll() const ;
- void ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk=kNULLTASK, AliRecoParam::EventSpecie_t es=AliRecoParam::kDefault) const ;
- void UnSet(QABIT_t bit, AliRecoParam::EventSpecie_t es) ;
- void UnSet(QABIT_t bit, Int_t es) ;
+ static void Close() ;
+ static char * GetAliTaskName(ALITASK_t tsk) ;
+ static const TString GetExpert() { return fkgExpert ; }
+ static UInt_t GetExpertBit() { return fkgExpertBit ; }
+ static const TString GetLabLocalFile() { return fkgLabLocalFile ; }
+ static const TString GetLabLocalOCDB() { return fkgLabLocalOCDB ; }
+ static const TString GetLabAliEnOCDB() { return fkgLabAliEnOCDB ; }
+ static DETECTORINDEX_t GetDetIndex(const char * name) ;
+ static const TString GetDetName(DETECTORINDEX_t det) { return fgDetNames[det] ; }
+ static const char * GetDetName(Int_t det) ;
+ static const TString GetGRPPath() { return fgGRPPath ; }
+ static UInt_t GetQABit() { return fkgQABit ; }
+ static TFile * GetQADataFile(const char * name, const Int_t run) ;
+ static TFile * GetQADataFile(const char * fileName) ;
+ static const char * GetQADataFileName(const char * name, const Int_t run)
+ {return Form("%s.%s.%d.root", name, fgQADataFileName.Data(), run) ; }
+ static const char * GetQADataFileName() { return fgQADataFileName.Data() ; }
+ static const char * GetQAName() { return fkgQAName ; }
+ static const char * GetQACorrName() { return fkgQACorrNtName ; }
+ static TFile * GetQAResultFile() ;
+ static const char * GetQAResultFileName() { return (fgQAResultDirName + fgQAResultFileName).Data() ; }
+ static const char * GetQARefDefaultStorage() { return fkgQARefOCDBDefault.Data() ; }
+ static const char * GetQARefFileName() { return fgQARefFileName ; }
+ static const char * GetQARefStorage() { return fgQARefDirName.Data() ; }
+ static const char * GetRefOCDBDirName() { return fkgRefOCDBDirName.Data() ; }
+ static const char * GetRefDataDirName() { return fkgRefDataDirName.Data() ; }
+ static const TString GetRunTypeName(RUNTYPE_t rt = kNULLTYPE) ;
+ static TASKINDEX_t GetTaskIndex(const char * name) ;
+ static const TString GetTaskName(UInt_t tsk) { return fgTaskNames[tsk] ; }
+ Bool_t IsSet(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit) const ;
+ Bool_t IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk) const ;
+ Bool_t IsSetAny(DETECTORINDEX_t det) const ;
+ void Merge(TCollection * list) ;
+ void Set(QABIT_t bit) ;
+ static void SetQAResultDirName(const char * name) ;
+ static void SetQARefStorage(const char * name) ;
+ static void SetQARefDataDirName(RUNTYPE_t rt) { fkgRefDataDirName = GetRunTypeName(rt) ; }
+ static void SetQARefDataDirName(const char * name) ;
+ void Show() const { ShowStatus(fDet, fTask) ; }
+ void Show(DETECTORINDEX_t det) const { ShowStatus(det) ; }
+ void ShowAll() const ;
+ void UnSet(QABIT_t bit) ;
private:
+
+ Bool_t CheckRange(DETECTORINDEX_t det) const ;
+ Bool_t CheckRange(ALITASK_t tsk) const ;
+ Bool_t CheckRange(QABIT_t bit) const ;
+ char * GetBitName(QABIT_t bit) const ;
+ ULong_t GetStatus(DETECTORINDEX_t det) const { return fQA[det] ;}
+ void Finish() const ;
+ ULong_t Offset(ALITASK_t tsk) const ;
+ void ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk=kNULLTASK) const ;
+ void ShowASCIIStatus(DETECTORINDEX_t det, ALITASK_t tsk, ULong_t status) const ;
+ void ResetStatus(DETECTORINDEX_t det) { fQA[det] = 0 ; }
+ void Set(DETECTORINDEX_t det) { fDet = det ;}
+ void Set(ALITASK_t tsk) { fTask = tsk ; AliDebug(1, Form("Ready to set QA status in %s", GetAliTaskName(tsk) )) ; }
+ void SetStatus(DETECTORINDEX_t det, UShort_t status) { fQA[det] = status ; }
+ void SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit) ;
+ void UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, QABIT_t bit) ;
- Bool_t CheckRange(DETECTORINDEX_t det) const ;
- Bool_t CheckRange(ALITASK_t tsk) const ;
- Bool_t CheckRange(QABIT_t bit) const ;
- Bool_t CheckRange(AliRecoParam::EventSpecie_t es) const ;
- const char * GetBitName(QABIT_t bit) const ;
- ULong_t GetStatus(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es) const { return fQA[det*fNEventSpecies+(Int_t)TMath::Log2(es)] ;}
- void Finish() const ;
- ULong_t Offset(ALITASK_t tsk) const ;
- void ShowASCIIStatus(AliRecoParam::EventSpecie_t es, DETECTORINDEX_t det, ALITASK_t tsk, ULong_t status) const ;
- void ResetStatus(DETECTORINDEX_t det) ;
- void Set(DETECTORINDEX_t det) { fDet = det ;}
- void Set(ALITASK_t tsk) { fTask = tsk ; AliDebug(1, Form("Ready to set QA status in %s", GetAliTaskName(tsk) )) ; }
- void SetStatus(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es, ULong_t status) { fQA[det*fNEventSpecies+(Int_t)TMath::Log2(es)] = status ; }
- void SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) ;
- void UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) ;
+ static AliQA * fgQA ; // pointer to the instance of the singleton
+ Int_t fNdet ; // number of detectors
+ ULong_t * fQA ; //[fNdet] the status word 4 bits for SIM, REC, ESD, ANA each
+ DETECTORINDEX_t fDet ; //! the current detector (ITS, TPC, ....)
+ ALITASK_t fTask ; //! the current environment (SIM, REC, ESD, ANA)
+ static TString fgDetNames[] ; //! list of detector names
+ static TString fgGRPPath ; //! path of the GRP object in OCDB
+ static TFile * fgQADataFile ; //! the output file where the quality assurance maker store their results
+ static TString fgQADataFileName ; //! the name of the file where the quality assurance maker store their results
+ static TFile * fgQARefFile ; //! the output file where the quality assurance maker store their results
+ static TString fgQARefDirName ; //! name of directory where to find the reference data file
+ static TString fgQARefFileName ; //! file name where to find the reference data
+ static TFile * fgQAResultFile ; //! File where to find the QA result
+ static TString fgQAResultDirName ; //! the location of the output file where the QA results are stored
+ static TString fgQAResultFileName ; //! the output file where the QA results are stored
+ static TString fgRTNames[] ; //! list of Run Type names
+ static TString fgTaskNames[] ; //! list of tasks names
+ static const TString fkgExpert ; //! name for the expert directory
+ static const UInt_t fkgExpertBit ; //! TObject bit identifing the object as "expert"
+ static const TString fkgLabLocalFile ; //! label to identify a file as local
+ static const TString fkgLabLocalOCDB ; //! label to identify a file as local OCDB
+ static const TString fkgLabAliEnOCDB ; //! label to identify a file as AliEn OCDB
+ static const TString fkgRefFileName ; //! name of Reference File Name
+ static const UInt_t fkgQABit ; //! bit in the QA data object which is set when Checker does not return 0
+ static const TString fkgQAName ; //! name of QA object
+ static const TString fkgQACorrNtName ; //! name of QA Correlation Ntuple
+ static const TString fkgRefOCDBDirName ; //! name of Reference directory name in OCDB
+ static TString fkgRefDataDirName ; //! name of Reference directory name in OCDB for data
+ static const TString fkgQARefOCDBDefault ; //! default storage for QA in OCDB
- static AliQA * fgQA ; // pointer to the instance of the singleton
- Int_t fNdet ; // number of detectors
- Int_t fNEventSpecies ; // number of Event Species (see AliRecoParam)
- Int_t fLengthQA ; // Auxiliary length of fQA
- ULong_t * fQA ; //[fLengthQA] the status word 4 bits for SIM, REC, ESD, ANA each
- DETECTORINDEX_t fDet ; //! the current detector (ITS, TPC, ....)
- ALITASK_t fTask ; //! the current environment (SIM, REC, ESD, ANA)
- AliRecoParam::EventSpecie_t fEventSpecie ; //! the current event specie
- static TString fgDetNames[] ; //! list of detector names
- static TString fgGRPPath ; //! path of the GRP object in OCDB
- static TFile * fgQADataFile ; //! the output file where the quality assurance maker store their results
- static TString fgQADataFileName ; //! the name of the file where the quality assurance maker store their results
- static TFile * fgQARefFile ; //! the output file where the quality assurance maker store their results
- static TString fgQARefDirName ; //! name of directory where to find the reference data file
- static TString fgQARefFileName ; //! file name where to find the reference data
- static TFile * fgQAResultFile ; //! File where to find the QA result
- static TString fgQAResultDirName ; //! the location of the output file where the QA results are stored
- static TString fgQAResultFileName ; //! the output file where the QA results are stored
- static TString fgRTNames[] ; //! list of Run Type names
- static TString fgTaskNames[] ; //! list of tasks names
- static const TString fgkExpert ; //! name for the expert directory
- static const UInt_t fgkExpertBit ; //! TObject bit identifing the object as "expert"
- static const TString fgkLabLocalFile ; //! label to identify a file as local
- static const TString fgkLabLocalOCDB ; //! label to identify a file as local OCDB
- static const TString fgkLabAliEnOCDB ; //! label to identify a file as AliEn OCDB
- static const TString fgkRefFileName ; //! name of Reference File Name
- static const UInt_t fgkQABit ; //! bit in the QA data object which is set when Checker does not return 0
- static const TString fgkQAName ; //! name of QA object
- static const TString fgkQACorrNtName ; //! name of QA Correlation Ntuple
- static const TString fgkRefOCDBDirName ; //! name of Reference directory name in OCDB
- static TString fgRefDataDirName ; //! name of Reference directory name in OCDB for data
- static const TString fgkQARefOCDBDefault ; //! default storage for QA in OCDB
- Bool_t * fEventSpecies ; //[fNEventSpecies] list of event species encountered in a run
-
- ClassDef(AliQA,2) //ALICE Quality Assurance Object
+ ClassDef(AliQA,1) //ALICE Quality Assurance Object
};
-#endif
+#endif
\ No newline at end of file
#include "AliRunInfo.h"
#include "AliLog.h"
#include "AliModule.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliQACheckerBase.h"
#include "AliCorrQAChecker.h"
fEventSpecie(AliRecoParam::kDefault)
{
// ctor: initialise checkers and open the data file
- for (Int_t det = 0 ; det < AliQA::kNDET ; det++)
+ for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++)
fCheckers[det] = NULL ;
}
{
// copy constructor
- for (Int_t det = 0 ; det < AliQA::kNDET ; det++)
+ for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++)
fCheckers[det] = NULL ;
}
if (fRunInfo)
delete fRunInfo ;
delete [] fCheckers ;
- AliQA::Close() ;
+ AliQAv1::Close() ;
}
//_____________________________________________________________________________
AliQACheckerBase * qac = NULL ;
- TString detName(AliQA::GetDetName(det)) ;
+ TString detName(AliQAv1::GetDetName(det)) ;
- if (det == AliQA::kGLOBAL) {
+ if (det == AliQAv1::kGLOBAL) {
qac = new AliGlobalQAChecker() ;
- } else if (det == AliQA::kCORR) {
+ } else if (det == AliQAv1::kCORR) {
qac = new AliCorrQAChecker() ;
} else {
AliDebug(1, Form("Retrieving QA checker for %s", detName.Data())) ;
{
// Opens and returns the file with the reference data
dirFile = NULL ;
- TString refStorage(AliQA::GetQARefStorage()) ;
-// if (refStorage.Contains(AliQA::GetLabLocalFile())) {
-// refStorage.ReplaceAll(AliQA::GetLabLocalFile(), "") ;
-// refStorage += AliQA::GetQARefFileName() ;
+ TString refStorage(AliQAv1::GetQARefStorage()) ;
+// if (refStorage.Contains(AliQAv1::GetLabLocalFile())) {
+// refStorage.ReplaceAll(AliQAv1::GetLabLocalFile(), "") ;
+// refStorage += AliQAv1::GetQARefFileName() ;
// if ( fRefFile )
// if ( fRefFile->IsOpen() )
// fRefFile->Close() ;
// AliWarning(Form("Directory %s/%s not found in %s", det, task, refStorage.Data())) ;
// }
// } else
- if (!refStorage.Contains(AliQA::GetLabLocalOCDB()) && !refStorage.Contains(AliQA::GetLabAliEnOCDB())) {
+ if (!refStorage.Contains(AliQAv1::GetLabLocalOCDB()) && !refStorage.Contains(AliQAv1::GetLabAliEnOCDB())) {
AliError(Form("%s is not a valid location for reference data", refStorage.Data())) ;
return ;
} else {
AliQAManager* manQA = AliQAManager::QAManager() ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if ( !AliQA::Instance()->IsEventSpecieSet(specie) )
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
continue ;
- //if ( strcmp(AliQA::GetRefDataDirName(), "") == 0 ) { // the name of the last level of the directory is not set (EventSpecie)
+ //if ( strcmp(AliQAv1::GetRefDataDirName(), "") == 0 ) { // the name of the last level of the directory is not set (EventSpecie)
// Get it from RunInfo
//if (!fRunInfo) // not yet set, get the info from GRP
// LoadRunInfoFromGRP() ;
- AliQA::SetQARefDataDirName(specie) ;
+ AliQAv1::SetQARefDataDirName(specie) ;
//}
if ( ! manQA->GetLock() ) {
- manQA->SetDefaultStorage(AliQA::GetQARefStorage()) ;
- manQA->SetSpecificStorage("*", AliQA::GetQARefStorage()) ;
+ manQA->SetDefaultStorage(AliQAv1::GetQARefStorage()) ;
+ manQA->SetSpecificStorage("*", AliQAv1::GetQARefStorage()) ;
manQA->SetRun(AliCDBManager::Instance()->GetRun()) ;
manQA->SetLock() ;
}
- char * detOCDBDir = Form("%s/%s/%s", det, AliQA::GetRefOCDBDirName(), AliQA::GetRefDataDirName()) ;
+ char * detOCDBDir = Form("%s/%s/%s", det, AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName()) ;
AliCDBEntry * entry = manQA->Get(detOCDBDir, manQA->GetRun()) ;
if (entry) {
dirOCDB = new TObjArray*[AliRecoParam::kNSpecies] ;
void AliQAChecker::LoadRunInfoFromGRP()
{
AliCDBManager* man = AliCDBManager::Instance() ;
- AliCDBEntry* entry = man->Get(AliQA::GetGRPPath().Data());
+ AliCDBEntry* entry = man->Get(AliQAv1::GetGRPPath().Data());
AliGRPObject* grpObject = 0x0;
if (entry) {
stopwatch.Start();
//search for all detectors QA directories
- TList * detKeyList = AliQA::GetQADataFile(fileName)->GetListOfKeys() ;
+ TList * detKeyList = AliQAv1::GetQADataFile(fileName)->GetListOfKeys() ;
TIter nextd(detKeyList) ;
TKey * detKey ;
while ( (detKey = dynamic_cast<TKey *>(nextd()) ) ) {
TString detName ;
TString detNameQA(detKey->GetName()) ;
Int_t det ;
- for ( det = 0; det < AliQA::kNDET ; det++) {
- detName = AliQA::GetDetName(det) ;
+ for ( det = 0; det < AliQAv1::kNDET ; det++) {
+ detName = AliQAv1::GetDetName(det) ;
if (detNameQA.Contains(detName)) {
fFoundDetectors+=detName ;
fFoundDetectors+="." ;
break ;
}
}
- TDirectory * detDir = AliQA::GetQADataFile(fileName)->GetDirectory(detKey->GetName()) ;
+ TDirectory * detDir = AliQAv1::GetQADataFile(fileName)->GetDirectory(detKey->GetName()) ;
TList * taskKeyList = detDir->GetListOfKeys() ;
TIter nextt(taskKeyList) ;
TKey * taskKey ;
AliInfo(Form("QA checker found for %s", detName.Data())) ;
if (!qac)
AliFatal(Form("QA checker not found for %s", detName.Data())) ;
- AliQA::ALITASK_t index = AliQA::kNULLTASK ;
- if ( taskName == AliQA::GetTaskName(AliQA::kHITS) )
- index = AliQA::kSIM ;
- if ( taskName == AliQA::GetTaskName(AliQA::kSDIGITS) )
- index = AliQA::kSIM ;
- if ( taskName == AliQA::GetTaskName(AliQA::kDIGITS) )
- index = AliQA::kSIM ;
- if ( taskName == AliQA::GetTaskName(AliQA::kRECPOINTS) )
- index = AliQA::kREC ;
- if ( taskName == AliQA::GetTaskName(AliQA::kTRACKSEGMENTS) )
- index = AliQA::kREC ;
- if ( taskName == AliQA::GetTaskName(AliQA::kRECPARTICLES) )
- index = AliQA::kREC ;
- if ( taskName == AliQA::GetTaskName(AliQA::kESDS) )
- index = AliQA::kESD ;
- qac->Init(AliQA::DETECTORINDEX_t(det)) ;
+ AliQAv1::ALITASK_t index = AliQAv1::kNULLTASK ;
+ if ( taskName == AliQAv1::GetTaskName(AliQAv1::kHITS) )
+ index = AliQAv1::kSIM ;
+ if ( taskName == AliQAv1::GetTaskName(AliQAv1::kSDIGITS) )
+ index = AliQAv1::kSIM ;
+ if ( taskName == AliQAv1::GetTaskName(AliQAv1::kDIGITS) )
+ index = AliQAv1::kSIM ;
+ if ( taskName == AliQAv1::GetTaskName(AliQAv1::kRECPOINTS) )
+ index = AliQAv1::kREC ;
+ if ( taskName == AliQAv1::GetTaskName(AliQAv1::kTRACKSEGMENTS) )
+ index = AliQAv1::kREC ;
+ if ( taskName == AliQAv1::GetTaskName(AliQAv1::kRECPARTICLES) )
+ index = AliQAv1::kREC ;
+ if ( taskName == AliQAv1::GetTaskName(AliQAv1::kESDS) )
+ index = AliQAv1::kESD ;
+ qac->Init(AliQAv1::DETECTORINDEX_t(det)) ;
TDirectory * refDir = NULL ;
TObjArray ** refOCDBDir = NULL ;
}
}
AliInfo("QA performed for following detectors:") ;
- for ( Int_t det = 0; det < AliQA::kNDET; det++) {
- if (fFoundDetectors.Contains(AliQA::GetDetName(det))) {
- printf("%s, ",AliQA::GetDetName(det)) ;
- fFoundDetectors.ReplaceAll(AliQA::GetDetName(det), "") ;
+ for ( Int_t det = 0; det < AliQAv1::kNDET; det++) {
+ if (fFoundDetectors.Contains(AliQAv1::GetDetName(det))) {
+ printf("%s, ",AliQAv1::GetDetName(det)) ;
+ fFoundDetectors.ReplaceAll(AliQAv1::GetDetName(det), "") ;
}
}
printf("\n") ;
}
//_____________________________________________________________________________
-Bool_t AliQAChecker::Run(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, TObjArray ** list)
+Bool_t AliQAChecker::Run(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
// run the Quality Assurance Checker for detector det, for task task starting from data in list
AliQACheckerBase * qac = GetDetQAChecker(det) ;
if (qac)
- AliDebug(1, Form("QA checker found for %s", AliQA::GetDetName(det).Data())) ;
+ AliDebug(1, Form("QA checker found for %s", AliQAv1::GetDetName(det).Data())) ;
if (!qac)
- AliError(Form("QA checker not found for %s", AliQA::GetDetName(det).Data())) ;
+ AliError(Form("QA checker not found for %s", AliQAv1::GetDetName(det).Data())) ;
- AliQA::ALITASK_t index = AliQA::kNULLTASK ;
- if ( task == AliQA::kRAWS )
- index = AliQA::kRAW ;
- else if ( task == AliQA::kHITS )
- index = AliQA::kSIM ;
- else if ( task == AliQA::kSDIGITS )
- index = AliQA::kSIM ;
- else if ( task == AliQA::kDIGITS )
- index = AliQA::kSIM ;
- else if ( task == AliQA::kRECPOINTS )
- index = AliQA::kREC ;
- else if ( task == AliQA::kTRACKSEGMENTS )
- index = AliQA::kREC ;
- else if ( task == AliQA::kRECPARTICLES )
- index = AliQA::kREC ;
- else if ( task == AliQA::kESDS )
- index = AliQA::kESD ;
+ AliQAv1::ALITASK_t index = AliQAv1::kNULLTASK ;
+ if ( task == AliQAv1::kRAWS )
+ index = AliQAv1::kRAW ;
+ else if ( task == AliQAv1::kHITS )
+ index = AliQAv1::kSIM ;
+ else if ( task == AliQAv1::kSDIGITS )
+ index = AliQAv1::kSIM ;
+ else if ( task == AliQAv1::kDIGITS )
+ index = AliQAv1::kSIM ;
+ else if ( task == AliQAv1::kRECPOINTS )
+ index = AliQAv1::kREC ;
+ else if ( task == AliQAv1::kTRACKSEGMENTS )
+ index = AliQAv1::kREC ;
+ else if ( task == AliQAv1::kRECPARTICLES )
+ index = AliQAv1::kREC ;
+ else if ( task == AliQAv1::kESDS )
+ index = AliQAv1::kESD ;
TDirectory * refDir = NULL ;
TObjArray ** refOCDBDir = NULL ;
qac->Init(det) ;
- GetRefSubDir(AliQA::GetDetName(det), AliQA::GetTaskName(task), refDir, refOCDBDir) ;
+ GetRefSubDir(AliQAv1::GetDetName(det), AliQAv1::GetTaskName(task), refDir, refOCDBDir) ;
qac->SetRefandData(refDir, refOCDBDir) ;
qac->Run(index, list) ;
return kTRUE ;
}
//_____________________________________________________________________________
-Bool_t AliQAChecker::Run(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, TNtupleD ** list)
+Bool_t AliQAChecker::Run(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, TNtupleD ** list)
{
// run the Quality Assurance Checker for detector det, for task task starting from data in list
AliQACheckerBase * qac = GetDetQAChecker(det) ;
if (qac)
- AliDebug(1, Form("QA checker found for %s", AliQA::GetDetName(det).Data())) ;
+ AliDebug(1, Form("QA checker found for %s", AliQAv1::GetDetName(det).Data())) ;
if (!qac)
- AliError(Form("QA checker not found for %s", AliQA::GetDetName(det).Data())) ;
+ AliError(Form("QA checker not found for %s", AliQAv1::GetDetName(det).Data())) ;
- AliQA::ALITASK_t index = AliQA::kNULLTASK ;
- if ( task == AliQA::kRAWS )
- index = AliQA::kRAW ;
- else if ( task == AliQA::kHITS )
- index = AliQA::kSIM ;
- else if ( task == AliQA::kSDIGITS )
- index = AliQA::kSIM ;
- else if ( task == AliQA::kDIGITS )
- index = AliQA::kSIM ;
- else if ( task == AliQA::kRECPOINTS )
- index = AliQA::kREC ;
- else if ( task == AliQA::kTRACKSEGMENTS )
- index = AliQA::kREC ;
- else if ( task == AliQA::kRECPARTICLES )
- index = AliQA::kREC ;
- else if ( task == AliQA::kESDS )
- index = AliQA::kESD ;
+ AliQAv1::ALITASK_t index = AliQAv1::kNULLTASK ;
+ if ( task == AliQAv1::kRAWS )
+ index = AliQAv1::kRAW ;
+ else if ( task == AliQAv1::kHITS )
+ index = AliQAv1::kSIM ;
+ else if ( task == AliQAv1::kSDIGITS )
+ index = AliQAv1::kSIM ;
+ else if ( task == AliQAv1::kDIGITS )
+ index = AliQAv1::kSIM ;
+ else if ( task == AliQAv1::kRECPOINTS )
+ index = AliQAv1::kREC ;
+ else if ( task == AliQAv1::kTRACKSEGMENTS )
+ index = AliQAv1::kREC ;
+ else if ( task == AliQAv1::kRECPARTICLES )
+ index = AliQAv1::kREC ;
+ else if ( task == AliQAv1::kESDS )
+ index = AliQAv1::kESD ;
TDirectory * refDir = NULL ;
TObjArray ** refOCDBDir = NULL ;
qac->Init(det) ;
- GetRefSubDir(AliQA::GetDetName(det), AliQA::GetTaskName(task), refDir, refOCDBDir) ;
+ GetRefSubDir(AliQAv1::GetDetName(det), AliQAv1::GetTaskName(task), refDir, refOCDBDir) ;
qac->SetRefandData(refDir, refOCDBDir) ;
qac->Run(index, list) ;
return kTRUE ;
#include <TFile.h>
class TNtupleD ;
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliRecoParam.h"
class AliCDBEntry ;
class AliRunInfo ;
// void SetRefDirName(const char * name) ;
virtual Bool_t Run(const char * fileName = NULL) ;
- virtual Bool_t Run(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, TObjArray ** list);
- virtual Bool_t Run(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, TNtupleD ** list);
+ virtual Bool_t Run(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, TObjArray ** list);
+ virtual Bool_t Run(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, TNtupleD ** list);
void SetRunInfo(AliRunInfo * ei) {fRunInfo = ei;}
private:
Bool_t fRunInfoOwner; //! owns fRunInfo or not
TFile * fRefFile ; //! Reference Data file
TString fFoundDetectors ; //! detectors for which the Quality assurance could be done
- AliQACheckerBase * fCheckers[AliQA::kNDET] ; //! list of detectors checkers
+ AliQACheckerBase * fCheckers[AliQAv1::kNDET] ; //! list of detectors checkers
AliRecoParam::EventSpecie_t fEventSpecie ; //! event specie deduced from the GRP data
ClassDef(AliQAChecker, 1) // class for running generation, simulation and digitization
};
// --- AliRoot header files ---
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliQACheckerBase.h"
#include "AliQADataMaker.h"
fUpTestValue(0x0)
{
// ctor
- fLowTestValue = new Float_t[AliQA::kNBIT] ;
- fUpTestValue = new Float_t[AliQA::kNBIT] ;
- fLowTestValue[AliQA::kINFO] = 0.5 ;
- fUpTestValue[AliQA::kINFO] = 1.0 ;
- fLowTestValue[AliQA::kWARNING] = 0.002 ;
- fUpTestValue[AliQA::kWARNING] = 0.5 ;
- fLowTestValue[AliQA::kERROR] = 0.0 ;
- fUpTestValue[AliQA::kERROR] = 0.002 ;
- fLowTestValue[AliQA::kFATAL] = -1.0 ;
- fUpTestValue[AliQA::kFATAL] = 0.0 ;
+ fLowTestValue = new Float_t[AliQAv1::kNBIT] ;
+ fUpTestValue = new Float_t[AliQAv1::kNBIT] ;
+ fLowTestValue[AliQAv1::kINFO] = 0.5 ;
+ fUpTestValue[AliQAv1::kINFO] = 1.0 ;
+ fLowTestValue[AliQAv1::kWARNING] = 0.002 ;
+ fUpTestValue[AliQAv1::kWARNING] = 0.5 ;
+ fLowTestValue[AliQAv1::kERROR] = 0.0 ;
+ fUpTestValue[AliQAv1::kERROR] = 0.002 ;
+ fLowTestValue[AliQAv1::kFATAL] = -1.0 ;
+ fUpTestValue[AliQAv1::kFATAL] = 0.0 ;
AliInfo("Default setting is:") ;
- printf( " INFO -> %1.5f < value < %1.5f \n", fLowTestValue[AliQA::kINFO], fUpTestValue[AliQA::kINFO]) ;
- printf( " WARNING -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQA::kWARNING], fUpTestValue[AliQA::kWARNING]) ;
- printf( " ERROR -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQA::kERROR], fUpTestValue[AliQA::kERROR]) ;
- printf( " FATAL -> %1.5f <= value < %1.5f \n", fLowTestValue[AliQA::kFATAL], fUpTestValue[AliQA::kFATAL]) ;
+ printf( " INFO -> %1.5f < value < %1.5f \n", fLowTestValue[AliQAv1::kINFO], fUpTestValue[AliQAv1::kINFO]) ;
+ printf( " WARNING -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kWARNING], fUpTestValue[AliQAv1::kWARNING]) ;
+ printf( " ERROR -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kERROR], fUpTestValue[AliQAv1::kERROR]) ;
+ printf( " FATAL -> %1.5f <= value < %1.5f \n", fLowTestValue[AliQAv1::kFATAL], fUpTestValue[AliQAv1::kFATAL]) ;
}
fUpTestValue(qac.fLowTestValue)
{
//copy ctor
- for (Int_t index = 0 ; index < AliQA::kNBIT ; index++) {
+ for (Int_t index = 0 ; index < AliQAv1::kNBIT ; index++) {
fLowTestValue[index] = qac.fLowTestValue[index] ;
fUpTestValue[index] = qac.fUpTestValue[index] ;
}
}
//____________________________________________________________________________
-Double_t * AliQACheckerBase::Check(AliQA::ALITASK_t /*index*/)
+Double_t * AliQACheckerBase::Check(AliQAv1::ALITASK_t /*index*/)
{
// Performs a basic checking
// Compares all the histograms stored in the directory
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
test[specie] = 1.0 ;
- if ( !AliQA::Instance()->IsEventSpecieSet(specie) )
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
continue ;
if (!fDataSubDir) {
test[specie] = 0. ; // nothing to check
}
//____________________________________________________________________________
-Double_t * AliQACheckerBase::Check(AliQA::ALITASK_t /*index*/, TObjArray ** list)
+Double_t * AliQACheckerBase::Check(AliQAv1::ALITASK_t /*index*/, TObjArray ** list)
{
// Performs a basic checking
// Compares all the histograms in the list
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
test[specie] = 1.0 ;
- if ( !AliQA::Instance()->IsEventSpecieSet(specie) )
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
continue ;
if (list[specie]->GetEntries() == 0)
test[specie] = 0. ; // nothing to check
count[specie] = 0 ;
while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
if ( hdata) {
- if ( hdata->TestBit(AliQA::GetExpertBit()) ) // does not perform the test for expert data
+ if ( hdata->TestBit(AliQAv1::GetExpertBit()) ) // does not perform the test for expert data
continue ;
TH1 * href = NULL ;
if (fRefSubDir)
}
//____________________________________________________________________________
-void AliQACheckerBase::Run(AliQA::ALITASK_t index, TObjArray ** list)
+void AliQACheckerBase::Run(AliQAv1::ALITASK_t index, TObjArray ** list)
{
- AliDebug(1, Form("Processing %s", AliQA::GetAliTaskName(index))) ;
+ AliDebug(1, Form("Processing %s", AliQAv1::GetAliTaskName(index))) ;
Double_t * rv = NULL ;
if ( !list)
rv = Check(index, list) ;
SetQA(index, rv) ;
- AliDebug(1, Form("Test result of %s", AliQA::GetAliTaskName(index))) ;
+ AliDebug(1, Form("Test result of %s", AliQAv1::GetAliTaskName(index))) ;
if (rv)
delete [] rv ;
void AliQACheckerBase::Finish() const
{
// wrap up and save QA in proper file
- AliQA * qa = AliQA::Instance() ;
+ AliQAv1 * qa = AliQAv1::Instance() ;
qa->Show() ;
- AliQA::GetQAResultFile()->cd() ;
+ AliQAv1::GetQAResultFile()->cd() ;
qa->Write(qa->GetName(), kWriteDelete) ;
- AliQA::GetQAResultFile()->Close() ;
+ AliQAv1::GetQAResultFile()->Close() ;
}
//____________________________________________________________________________
void AliQACheckerBase::SetHiLo(Float_t * hiValue, Float_t * lowValue)
{
AliInfo("Previous setting was:") ;
- printf( " INFO -> %1.5f < value < %1.5f \n", fLowTestValue[AliQA::kINFO], fUpTestValue[AliQA::kINFO]) ;
- printf( " WARNING -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQA::kWARNING], fUpTestValue[AliQA::kWARNING]) ;
- printf( " ERROR -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQA::kERROR], fUpTestValue[AliQA::kERROR]) ;
- printf( " FATAL -> %1.5f <= value < %1.5f \n", fLowTestValue[AliQA::kFATAL], fUpTestValue[AliQA::kFATAL]) ;
+ printf( " INFO -> %1.5f < value < %1.5f \n", fLowTestValue[AliQAv1::kINFO], fUpTestValue[AliQAv1::kINFO]) ;
+ printf( " WARNING -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kWARNING], fUpTestValue[AliQAv1::kWARNING]) ;
+ printf( " ERROR -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kERROR], fUpTestValue[AliQAv1::kERROR]) ;
+ printf( " FATAL -> %1.5f <= value < %1.5f \n", fLowTestValue[AliQAv1::kFATAL], fUpTestValue[AliQAv1::kFATAL]) ;
- for (Int_t index = 0 ; index < AliQA::kNBIT ; index++) {
+ for (Int_t index = 0 ; index < AliQAv1::kNBIT ; index++) {
fLowTestValue[index] = lowValue[index] ;
fUpTestValue[index] = hiValue[index] ;
}
AliInfo("Current setting is:") ;
- printf( " INFO -> %1.5f < value < %1.5f \n", fLowTestValue[AliQA::kINFO], fUpTestValue[AliQA::kINFO]) ;
- printf( " WARNING -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQA::kWARNING], fUpTestValue[AliQA::kWARNING]) ;
- printf( " ERROR -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQA::kERROR], fUpTestValue[AliQA::kERROR]) ;
- printf( " FATAL -> %1.5f <= value < %1.5f \n", fLowTestValue[AliQA::kFATAL], fUpTestValue[AliQA::kFATAL]) ;
+ printf( " INFO -> %1.5f < value < %1.5f \n", fLowTestValue[AliQAv1::kINFO], fUpTestValue[AliQAv1::kINFO]) ;
+ printf( " WARNING -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kWARNING], fUpTestValue[AliQAv1::kWARNING]) ;
+ printf( " ERROR -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kERROR], fUpTestValue[AliQAv1::kERROR]) ;
+ printf( " FATAL -> %1.5f <= value < %1.5f \n", fLowTestValue[AliQAv1::kFATAL], fUpTestValue[AliQAv1::kFATAL]) ;
}
//____________________________________________________________________________
-void AliQACheckerBase::SetQA(AliQA::ALITASK_t index, Double_t * value) const
+void AliQACheckerBase::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
{
// sets the QA according the return value of the Check
- AliQA * qa = AliQA::Instance(index) ;
+ AliQAv1 * qa = AliQAv1::Instance(index) ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
if ( value == NULL ) { // No checker is implemented, set all QA to Fatal
- qa->Set(AliQA::kFATAL, specie) ;
+ qa->Set(AliQAv1::kFATAL, specie) ;
} else {
- if ( value[specie] >= fLowTestValue[AliQA::kFATAL] && value[specie] < fUpTestValue[AliQA::kFATAL] )
- qa->Set(AliQA::kFATAL, specie) ;
- else if ( value[specie] > fLowTestValue[AliQA::kERROR] && value[specie] <= fUpTestValue[AliQA::kERROR] )
- qa->Set(AliQA::kERROR, specie) ;
- else if ( value[specie] > fLowTestValue[AliQA::kWARNING] && value[specie] <= fUpTestValue[AliQA::kWARNING] )
- qa->Set(AliQA::kWARNING, specie) ;
- else if ( value[specie] > fLowTestValue[AliQA::kINFO] && value[specie] <= fUpTestValue[AliQA::kINFO] )
- qa->Set(AliQA::kINFO, specie) ;
+ if ( value[specie] >= fLowTestValue[AliQAv1::kFATAL] && value[specie] < fUpTestValue[AliQAv1::kFATAL] )
+ qa->Set(AliQAv1::kFATAL, specie) ;
+ else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] && value[specie] <= fUpTestValue[AliQAv1::kERROR] )
+ qa->Set(AliQAv1::kERROR, specie) ;
+ else if ( value[specie] > fLowTestValue[AliQAv1::kWARNING] && value[specie] <= fUpTestValue[AliQAv1::kWARNING] )
+ qa->Set(AliQAv1::kWARNING, specie) ;
+ else if ( value[specie] > fLowTestValue[AliQAv1::kINFO] && value[specie] <= fUpTestValue[AliQAv1::kINFO] )
+ qa->Set(AliQAv1::kINFO, specie) ;
}
}
}
// --- ROOT system ---
#include <TNamed.h>
-#include "AliQA.h"
+#include "AliQAv1.h"
class TFile ;
class TH1 ;
class TObjArray ;
AliQACheckerBase& operator = (const AliQACheckerBase& qac) ;
virtual ~AliQACheckerBase() ; // dtor
- virtual void Init(const AliQA::DETECTORINDEX_t det) { AliQA::Instance(det) ; }
- void Run(AliQA::ALITASK_t tsk, TObjArray ** list = NULL);
- void Run(AliQA::ALITASK_t /*tsk*/, TNtupleD ** /*nt*/) {;}
+ virtual void Init(const AliQAv1::DETECTORINDEX_t det) { AliQAv1::Instance(det) ; }
+ void Run(AliQAv1::ALITASK_t tsk, TObjArray ** list = NULL);
+ void Run(AliQAv1::ALITASK_t /*tsk*/, TNtupleD ** /*nt*/) {;}
void SetHiLo(Float_t * hiValue, Float_t * lowValue) ;
void SetRefandData(TDirectory * ref, TObjArray ** refOCDB, TDirectory * data=NULL) { fRefSubDir = ref ; fRefOCDBSubDir = refOCDB, fDataSubDir = data ; }
protected:
- virtual Double_t * Check(AliQA::ALITASK_t index) ;
- virtual Double_t * Check(AliQA::ALITASK_t, TObjArray **) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t index) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t, TObjArray **) ;
Double_t DiffC(const TH1 * href, const TH1 * hin) const ;
Double_t DiffK(const TH1 * href, const TH1 * hin) const ;
void Finish() const ;
- virtual void SetQA(AliQA::ALITASK_t index, Double_t * value) const ;
+ virtual void SetQA(AliQAv1::ALITASK_t index, Double_t * value) const ;
TDirectory * fDataSubDir ; //! directory for the current task directory in the current detector directory in the data file
TDirectory * fRefSubDir ; //! directory for the current task directory in the current detector directory in the reference file
AliError("Max number of authorized QA objects is 10000") ;
} else {
if (expert)
- hist->SetBit(AliQA::GetExpertBit()) ;
+ hist->SetBit(AliQAv1::GetExpertBit()) ;
TH1 * histClone[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
histClone[specie] = CloneMe(hist, specie) ;
// clones a histogram
char * name = Form("%s_%s", AliRecoParam::GetEventSpecieName(specie), hist->GetName()) ;
TH1 * hClone = dynamic_cast<TH1 *>(hist->Clone(name)) ;
- if ( hist->TestBit(AliQA::GetExpertBit()) )
- hClone->SetBit(AliQA::GetExpertBit()) ;
+ if ( hist->TestBit(AliQAv1::GetExpertBit()) )
+ hClone->SetBit(AliQAv1::GetExpertBit()) ;
return hClone ;
}
//____________________________________________________________________________
-void AliQADataMaker::DefaultEndOfDetectorCycle(AliQA::TASKINDEX_t task)
+void AliQADataMaker::DefaultEndOfDetectorCycle(AliQAv1::TASKINDEX_t task)
{
// this method must be oveloaded by detectors
// sets the QA result to Fatal
- AliQA::Instance(AliQA::GetDetIndex(GetName())) ;
- AliQA * qa = AliQA::Instance(task) ;
+ AliQAv1::Instance(AliQAv1::GetDetIndex(GetName())) ;
+ AliQAv1 * qa = AliQAv1::Instance(task) ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
- qa->Set(AliQA::kFATAL, specie) ;
- AliQA::GetQAResultFile()->cd() ;
- qa->Write(AliQA::GetQAName(), kWriteDelete) ;
- AliQA::GetQAResultFile()->Close() ;
+ qa->Set(AliQAv1::kFATAL, specie) ;
+ AliQAv1::GetQAResultFile()->cd() ;
+ qa->Write(AliQAv1::GetQAName(), kWriteDelete) ;
+ AliQAv1::GetQAResultFile()->Close() ;
}
//____________________________________________________________________________
// --- Standard library ---
// --- AliRoot header files ---
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliRecoParam.h"
class AliQADataMaker: public TNamed {
virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE) = 0 ;
virtual Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t saveForCorr = kFALSE) = 0 ;
virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE) = 0 ;
- virtual void Exec(AliQA::TASKINDEX_t, TObject * data) = 0 ;
+ virtual void Exec(AliQAv1::TASKINDEX_t, TObject * data) = 0 ;
virtual void EndOfCycle() = 0 ;
- virtual void EndOfCycle(AliQA::TASKINDEX_t ) = 0 ;
+ virtual void EndOfCycle(AliQAv1::TASKINDEX_t ) = 0 ;
void Finish() const ;
virtual TH1 * GetDigitsData(const Int_t index) = 0 ;
virtual TH1 * GetESDsData(const Int_t index) = 0 ;
const char * GetDetectorDirName() const { return fDetectorDirName.Data() ; }
TList * GetParameterList() const { return fParameterList[AliRecoParam::AConvert(fEventSpecie)] ; }
Int_t Increment() { return ++fCycleCounter ; }
- virtual TObjArray** Init(AliQA::TASKINDEX_t, Int_t cycles = -1) = 0 ;
- virtual void Init(AliQA::TASKINDEX_t, TObjArray ** list, Int_t run, Int_t cycles = -1) = 0 ;
+ virtual TObjArray** Init(AliQAv1::TASKINDEX_t, Int_t cycles = -1) = 0 ;
+ virtual void Init(AliQAv1::TASKINDEX_t, TObjArray ** list, Int_t run, Int_t cycles = -1) = 0 ;
Bool_t IsCycleDone() const { return fCycleCounter > fCycle ? kTRUE : kFALSE ; }
void Reset() { fCycleCounter = 0 ; }
void SetCycle(Int_t nevts) { fCycle = nevts ; }
void SetWriteExpert() { fWriteExpert = kTRUE ; }
virtual void StartOfCycle(Int_t run = -1) = 0 ;
- virtual void StartOfCycle(AliQA::TASKINDEX_t, Int_t run, const Bool_t sameCycle = kFALSE) = 0 ;
+ virtual void StartOfCycle(AliQAv1::TASKINDEX_t, Int_t run, const Bool_t sameCycle = kFALSE) = 0 ;
void UnSetWriteExpert() { fWriteExpert = kFALSE ; }
Bool_t WriteExpert() { return fWriteExpert ; }
void SetEventSpecie(AliRecoParam::EventSpecie_t es) { fEventSpecie = es ; }
Int_t Add2List(TH1 * hist, const Int_t index, TObjArray ** list, const Bool_t expert = kFALSE, const Bool_t saveForCorr = kFALSE) ;
TH1 * CloneMe(TH1 * hist, Int_t specie) const ;
- virtual void DefaultEndOfDetectorCycle(AliQA::TASKINDEX_t task ) ;
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list ) = 0 ;
+ virtual void DefaultEndOfDetectorCycle(AliQAv1::TASKINDEX_t task ) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list ) = 0 ;
TObject * GetData(TObjArray ** list, const Int_t index) ;
virtual void InitDigits() = 0 ;
virtual void InitESDs() = 0 ;
void AliQADataMakerRec::EndOfCycle()
{
// Finishes a cycle of QA for all the tasks
- EndOfCycle(AliQA::kRAWS) ;
- EndOfCycle(AliQA::kRECPOINTS) ;
- EndOfCycle(AliQA::kESDS) ;
+ EndOfCycle(AliQAv1::kRAWS) ;
+ EndOfCycle(AliQAv1::kRECPOINTS) ;
+ EndOfCycle(AliQAv1::kESDS) ;
ResetCycle() ;
}
//____________________________________________________________________________
-void AliQADataMakerRec::EndOfCycle(AliQA::TASKINDEX_t task)
+void AliQADataMakerRec::EndOfCycle(AliQAv1::TASKINDEX_t task)
{
// Finishes a cycle of QA
TObjArray ** list = NULL ;
- if ( task == AliQA::kRAWS )
+ if ( task == AliQAv1::kRAWS )
list = fRawsQAList ;
- else if ( task == AliQA::kRECPOINTS )
+ else if ( task == AliQAv1::kRECPOINTS )
list = fRecPointsQAList ;
- else if ( task == AliQA::kESDS )
+ else if ( task == AliQAv1::kESDS )
list = fESDsQAList ;
EndOfDetectorCycle(task, list) ;
TDirectory * subDir = NULL ;
if (fDetectorDir)
- subDir = fDetectorDir->GetDirectory(AliQA::GetTaskName(task)) ;
+ subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ;
if ( subDir ) {
subDir->cd() ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
TIter next(list[specie]) ;
TObject * obj ;
while( (obj = next()) ) {
- if (!obj->TestBit(AliQA::GetExpertBit()))
+ if (!obj->TestBit(AliQAv1::GetExpertBit()))
obj->Write() ;
}
if (WriteExpert()) {
- TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQA::GetExpert()) ;
+ TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ;
if ( expertDir ) { // Write only if requested
expertDir->cd() ;
next.Reset() ;
while( (obj = next()) ) {
- if (!obj->TestBit(AliQA::GetExpertBit()))
+ if (!obj->TestBit(AliQAv1::GetExpertBit()))
continue ;
obj->Write() ;
}
}
if ( !fCorrNt )
continue ;
- if (fCorrNt[specie] && AliQA::GetDetIndex(GetName()) == AliQA::kCORR) {
+ if (fCorrNt[specie] && AliQAv1::GetDetIndex(GetName()) == AliQAv1::kCORR) {
eventSpecieDir->cd() ;
fCorrNt[specie]->Write() ;
}
}
//____________________________________________________________________________
-void AliQADataMakerRec::Exec(AliQA::TASKINDEX_t task, TObject * data)
+void AliQADataMakerRec::Exec(AliQAv1::TASKINDEX_t task, TObject * data)
{
// creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs)
- if ( task == AliQA::kRAWS ) {
+ if ( task == AliQAv1::kRAWS ) {
AliDebug(1, "Processing Raws QA") ;
AliRawReader * rawReader = dynamic_cast<AliRawReader *>(data) ;
if (rawReader)
MakeRaws(rawReader) ;
else
AliInfo("Raw data are not processed") ;
- } else if ( task == AliQA::kRECPOINTS ) {
+ } else if ( task == AliQAv1::kRECPOINTS ) {
AliDebug(1, "Processing RecPoints QA") ;
TTree * tree = dynamic_cast<TTree *>(data) ;
if (tree) {
} else {
AliWarning("data are not a TTree") ;
}
- } else if ( task == AliQA::kESDS ) {
+ } else if ( task == AliQAv1::kESDS ) {
AliDebug(1, "Processing ESDs QA") ;
AliESDEvent * esd = dynamic_cast<AliESDEvent *>(data) ;
if (esd)
}
//____________________________________________________________________________
-TObjArray ** AliQADataMakerRec::Init(AliQA::TASKINDEX_t task, Int_t cycles)
+TObjArray ** AliQADataMakerRec::Init(AliQAv1::TASKINDEX_t task, Int_t cycles)
{
// general intialisation
InitRecoParams() ;
if (cycles > 0)
SetCycle(cycles) ;
- if ( task == AliQA::kRAWS ) {
+ if ( task == AliQAv1::kRAWS ) {
if (! fRawsQAList ) {
fRawsQAList = new TObjArray *[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
fRawsQAList[specie] = new TObjArray(100) ;
- fRawsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
+ fRawsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
}
InitRaws() ;
}
rv = fRawsQAList ;
- } else if ( task == AliQA::kRECPOINTS ) {
+ } else if ( task == AliQAv1::kRECPOINTS ) {
if ( ! fRecPointsQAList ) {
fRecPointsQAList = new TObjArray *[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
fRecPointsQAList[specie] = new TObjArray(100) ;
- fRecPointsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
+ fRecPointsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
}
InitRecPoints() ;
}
rv = fRecPointsQAList ;
- } else if ( task == AliQA::kESDS ) {
+ } else if ( task == AliQAv1::kESDS ) {
if ( ! fESDsQAList ) {
fESDsQAList = new TObjArray *[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
fESDsQAList[specie] = new TObjArray(100) ;
- fESDsQAList[specie]->SetName(Form("%s_%s", GetName(), AliQA::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
+ fESDsQAList[specie]->SetName(Form("%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
}
InitESDs() ;
}
}
//____________________________________________________________________________
-void AliQADataMakerRec::Init(AliQA::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles)
+void AliQADataMakerRec::Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles)
{
// Intialisation by passing the list of QA data booked elsewhere
if (cycles > 0)
SetCycle(cycles) ;
- if ( task == AliQA::kRAWS ) {
+ if ( task == AliQAv1::kRAWS ) {
fRawsQAList = list ;
- } else if ( task == AliQA::kRECPOINTS ) {
+ } else if ( task == AliQAv1::kRECPOINTS ) {
fRecPointsQAList = list ;
- } else if ( task == AliQA::kESDS ) {
+ } else if ( task == AliQAv1::kESDS ) {
fESDsQAList = list ;
}
}
{
// Finishes a cycle of QA for all the tasks
Bool_t samecycle = kFALSE ;
- StartOfCycle(AliQA::kRAWS, run, samecycle) ;
+ StartOfCycle(AliQAv1::kRAWS, run, samecycle) ;
samecycle = kTRUE ;
- StartOfCycle(AliQA::kRECPOINTS, run, samecycle) ;
- StartOfCycle(AliQA::kESDS, run, samecycle) ;
+ StartOfCycle(AliQAv1::kRECPOINTS, run, samecycle) ;
+ StartOfCycle(AliQAv1::kESDS, run, samecycle) ;
}
//____________________________________________________________________________
-void AliQADataMakerRec::StartOfCycle(AliQA::TASKINDEX_t task, Int_t run, const Bool_t sameCycle)
+void AliQADataMakerRec::StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle)
{
// Finishes a cycle of QA data acquistion
if ( run > 0 )
ResetCycle() ;
if (fOutput)
fOutput->Close() ;
- fOutput = AliQA::GetQADataFile(GetName(), fRun) ;
+ fOutput = AliQAv1::GetQADataFile(GetName(), fRun) ;
}
AliInfo(Form(" Run %d Cycle %d task %s file %s",
- fRun, fCurrentCycle, AliQA::GetTaskName(task).Data(), fOutput->GetName() )) ;
+ fRun, fCurrentCycle, AliQAv1::GetTaskName(task).Data(), fOutput->GetName() )) ;
fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ;
if (!fDetectorDir)
fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ;
- TDirectory * subDir = fDetectorDir->GetDirectory(AliQA::GetTaskName(task)) ;
+ TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ;
if (!subDir)
- subDir = fDetectorDir->mkdir(AliQA::GetTaskName(task)) ;
+ subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;
for ( Int_t specie = AliRecoParam::kDefault ; specie < AliRecoParam::kNSpecies ; specie++ ) {
TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(specie)) ;
if (!eventSpecieDir)
eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(specie)) ;
- TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQA::GetExpert()) ;
+ TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ;
if (!expertDir)
- expertDir = eventSpecieDir->mkdir(AliQA::GetExpert()) ;
+ expertDir = eventSpecieDir->mkdir(AliQAv1::GetExpert()) ;
}
StartOfDetectorCycle() ;
}
// --- AliRoot header files ---
class AliDetectorRecoParam ;
#include "AliQADataMaker.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
class AliQADataMakerRec: public AliQADataMaker {
virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE) { return Add2List(hist, index, fRecPointsQAList, expert) ; }
virtual Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t saveForCorr = kFALSE) { return Add2List(hist, index, fRawsQAList, expert, saveForCorr) ; }
virtual Int_t Add2SDigitsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/) { return -1 ; }
- virtual void Exec(AliQA::TASKINDEX_t task, TObject * data) ;
+ virtual void Exec(AliQAv1::TASKINDEX_t task, TObject * data) ;
virtual void EndOfCycle() ;
- virtual void EndOfCycle(AliQA::TASKINDEX_t task) ;
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** ) {AliInfo("To be implemented by detectors");}
+ virtual void EndOfCycle(AliQAv1::TASKINDEX_t task) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** ) {AliInfo("To be implemented by detectors");}
virtual TH1 * GetDigitsData(const Int_t /*index*/) { return NULL ; }
virtual TH1 * GetESDsData(const Int_t index) { return dynamic_cast<TH1 *>(GetData(fESDsQAList, index)) ; }
virtual TH1 * GetHitsData(const Int_t /*index*/) { return NULL ; }
virtual TH1 * GetRecPointsData(const Int_t index) { return dynamic_cast<TH1 *>(GetData(fRecPointsQAList, index)) ; }
virtual TH1 * GetRawsData(const Int_t index) { return dynamic_cast<TH1 *>(GetData(fRawsQAList, index)) ; }
virtual TH1 * GetSDigitsData(const Int_t /*index*/) { return NULL ; }
- virtual TObjArray** Init(AliQA::TASKINDEX_t task, Int_t cycles = -1) ;
- virtual void Init(AliQA::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles = -1) ;
+ virtual TObjArray** Init(AliQAv1::TASKINDEX_t task, Int_t cycles = -1) ;
+ virtual void Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles = -1) ;
virtual void StartOfCycle(Int_t run = -1) ;
- virtual void StartOfCycle(AliQA::TASKINDEX_t task, Int_t run, const Bool_t sameCycle = kFALSE) ;
+ virtual void StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle = kFALSE) ;
virtual void SetRecoParam(const AliDetectorRecoParam *param) { fRecoParam = param; }
void AliQADataMakerSim::EndOfCycle()
{
// Finishes a cycle of QA for all tasks
- EndOfCycle(AliQA::kHITS) ;
- EndOfCycle(AliQA::kSDIGITS) ;
- EndOfCycle(AliQA::kDIGITS) ;
+ EndOfCycle(AliQAv1::kHITS) ;
+ EndOfCycle(AliQAv1::kSDIGITS) ;
+ EndOfCycle(AliQAv1::kDIGITS) ;
ResetCycle() ;
}
//____________________________________________________________________________
-void AliQADataMakerSim::EndOfCycle(AliQA::TASKINDEX_t task)
+void AliQADataMakerSim::EndOfCycle(AliQAv1::TASKINDEX_t task)
{
// Finishes a cycle of QA data acquistion
TObjArray ** list = NULL ;
- if ( task == AliQA::kHITS )
+ if ( task == AliQAv1::kHITS )
list = fHitsQAList ;
- else if ( task == AliQA::kSDIGITS )
+ else if ( task == AliQAv1::kSDIGITS )
list = fSDigitsQAList ;
- else if ( task == AliQA::kDIGITS )
+ else if ( task == AliQAv1::kDIGITS )
list = fDigitsQAList ;
if ( ! list )
EndOfDetectorCycle(task, list) ;
TDirectory * subDir = NULL ;
if (fDetectorDir)
- subDir = fDetectorDir->GetDirectory(AliQA::GetTaskName(task)) ;
+ subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ;
if (subDir) {
subDir->cd() ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
TIter next(list[specie]) ;
TObject * obj ;
while ( (obj = next()) ) {
- if (!obj->TestBit(AliQA::GetExpertBit()))
+ if (!obj->TestBit(AliQAv1::GetExpertBit()))
obj->Write() ;
}
if (WriteExpert()) {
- TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQA::GetExpert()) ;
+ TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ;
if ( expertDir ) {
expertDir->cd() ;
next.Reset() ;
while ( (obj = next()) ) {
- if (!obj->TestBit(AliQA::GetExpertBit()))
+ if (!obj->TestBit(AliQAv1::GetExpertBit()))
continue ;
obj->Write() ;
}
}
//____________________________________________________________________________
-void AliQADataMakerSim::Exec(AliQA::TASKINDEX_t task, TObject * data)
+void AliQADataMakerSim::Exec(AliQAv1::TASKINDEX_t task, TObject * data)
{
// creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs)
- if ( task == AliQA::kHITS ) {
+ if ( task == AliQAv1::kHITS ) {
AliDebug(1, "Processing Hits QA") ;
TClonesArray * arr = dynamic_cast<TClonesArray *>(data) ;
if (arr) {
AliWarning("data are neither a TClonesArray nor a TTree") ;
}
}
- } else if ( task == AliQA::kSDIGITS ) {
+ } else if ( task == AliQAv1::kSDIGITS ) {
AliDebug(1, "Processing SDigits QA") ;
TClonesArray * arr = dynamic_cast<TClonesArray *>(data) ;
if (arr) {
AliWarning("data are neither a TClonesArray nor a TTree") ;
}
}
- } else if ( task == AliQA::kDIGITS ) {
+ } else if ( task == AliQAv1::kDIGITS ) {
AliDebug(1, "Processing Digits QA") ;
TClonesArray * arr = dynamic_cast<TClonesArray *>(data) ;
if (arr) {
}
//____________________________________________________________________________
-TObjArray ** AliQADataMakerSim::Init(AliQA::TASKINDEX_t task, Int_t cycles)
+TObjArray ** AliQADataMakerSim::Init(AliQAv1::TASKINDEX_t task, Int_t cycles)
{
// general intialisation
if (cycles > 0)
SetCycle(cycles) ;
TObjArray ** rv = NULL ;
- if ( task == AliQA::kHITS ) {
+ if ( task == AliQAv1::kHITS ) {
if ( ! fHitsQAList ) {
fHitsQAList = new TObjArray *[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
fHitsQAList[specie] = new TObjArray(100) ;
- fHitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
+ fHitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
}
InitHits() ;
}
rv = fHitsQAList ;
- } else if ( task == AliQA::kSDIGITS ) {
+ } else if ( task == AliQAv1::kSDIGITS ) {
if ( ! fSDigitsQAList ) {
fSDigitsQAList = new TObjArray *[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
fSDigitsQAList[specie] = new TObjArray(100) ;
- fSDigitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
+ fSDigitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
}
InitSDigits() ;
}
rv = fSDigitsQAList ;
- } else if ( task == AliQA::kDIGITS ) {
+ } else if ( task == AliQAv1::kDIGITS ) {
if ( ! fDigitsQAList ) {
fDigitsQAList = new TObjArray *[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
fDigitsQAList[specie] = new TObjArray(100) ;
- fDigitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
+ fDigitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
}
InitDigits() ;
}
}
//____________________________________________________________________________
-void AliQADataMakerSim::Init(AliQA::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles)
+void AliQADataMakerSim::Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles)
{
// Intialisation by passing the list of QA data booked elsewhere
if (cycles > 0)
SetCycle(cycles) ;
- if ( task == AliQA::kHITS ) {
+ if ( task == AliQAv1::kHITS ) {
fHitsQAList = list ;
- } else if ( task == AliQA::kSDIGITS) {
+ } else if ( task == AliQAv1::kSDIGITS) {
fSDigitsQAList = list ;
- } else if ( task == AliQA::kDIGITS ) {
+ } else if ( task == AliQAv1::kDIGITS ) {
fDigitsQAList = list ;
}
}
{
// Finishes a cycle of QA for all tasks
Bool_t samecycle = kFALSE ;
- StartOfCycle(AliQA::kHITS, run, samecycle) ;
+ StartOfCycle(AliQAv1::kHITS, run, samecycle) ;
samecycle = kTRUE ;
- StartOfCycle(AliQA::kSDIGITS, run, samecycle) ;
- StartOfCycle(AliQA::kDIGITS, run, samecycle) ;
+ StartOfCycle(AliQAv1::kSDIGITS, run, samecycle) ;
+ StartOfCycle(AliQAv1::kDIGITS, run, samecycle) ;
}
//____________________________________________________________________________
-void AliQADataMakerSim::StartOfCycle(AliQA::TASKINDEX_t task, Int_t run, const Bool_t sameCycle)
+void AliQADataMakerSim::StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle)
{
// Finishes a cycle of QA data acquistion
if ( run > 0 )
ResetCycle() ;
if (fOutput)
fOutput->Close() ;
- fOutput = AliQA::GetQADataFile(GetName(), fRun) ;
+ fOutput = AliQAv1::GetQADataFile(GetName(), fRun) ;
}
AliInfo(Form(" Run %d Cycle %d task %s file %s",
- fRun, fCurrentCycle, AliQA::GetTaskName(task).Data(), fOutput->GetName() )) ;
+ fRun, fCurrentCycle, AliQAv1::GetTaskName(task).Data(), fOutput->GetName() )) ;
fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ;
if (!fDetectorDir)
fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ;
- TDirectory * subDir = fDetectorDir->GetDirectory(AliQA::GetTaskName(task)) ;
+ TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ;
if (!subDir)
- subDir = fDetectorDir->mkdir(AliQA::GetTaskName(task)) ;
+ subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;
for ( Int_t index = AliRecoParam::kDefault ; index < AliRecoParam::kNSpecies ; index++ ) {
TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(index)) ;
if (!eventSpecieDir)
eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(index)) ;
- TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQA::GetExpert()) ;
+ TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ;
if (!expertDir)
- expertDir = eventSpecieDir->mkdir(AliQA::GetExpert()) ;
+ expertDir = eventSpecieDir->mkdir(AliQAv1::GetExpert()) ;
}
StartOfDetectorCycle() ;
}
virtual Int_t Add2RecPointsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/) { return -1 ; }
virtual Int_t Add2RawsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*saveForCorr = kFALSE*/) { return -1 ; }
virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE) { return Add2List(hist, index, fSDigitsQAList, expert) ; }
- virtual void Exec(AliQA::TASKINDEX_t task, TObject * data) ;
+ virtual void Exec(AliQAv1::TASKINDEX_t task, TObject * data) ;
virtual void EndOfCycle() ;
- virtual void EndOfCycle(AliQA::TASKINDEX_t task) ;
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** ) {AliInfo("To be implemented by detectors");}
+ virtual void EndOfCycle(AliQAv1::TASKINDEX_t task) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** ) {AliInfo("To be implemented by detectors");}
virtual TH1 * GetDigitsData(const Int_t index) { return dynamic_cast<TH1 *>(GetData(fDigitsQAList, index)) ; }
virtual TH1 * GetESDsData(const Int_t /*index*/) { return NULL ; }
virtual TH1 * GetHitsData(const Int_t index) { return dynamic_cast<TH1 *>(GetData(fHitsQAList, index)) ; }
virtual TH1 * GetRecPointsData(const Int_t /*index*/) { return NULL ; }
virtual TH1 * GetRawsData(const Int_t /*index*/) { return NULL ; }
virtual TH1 * GetSDigitsData(const Int_t index) { return dynamic_cast<TH1 *>(GetData(fSDigitsQAList, index)) ; }
- virtual TObjArray** Init(AliQA::TASKINDEX_t task, Int_t cycles = -1) ;
- virtual void Init(AliQA::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles = -1) ;
+ virtual TObjArray** Init(AliQAv1::TASKINDEX_t task, Int_t cycles = -1) ;
+ virtual void Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles = -1) ;
virtual void StartOfCycle(Int_t run = -1) ;
- virtual void StartOfCycle(AliQA::TASKINDEX_t task, Int_t run, const Bool_t sameCycle = kFALSE) ;
+ virtual void StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle = kFALSE) ;
protected:
// class for running the QA makers //
// //
// AliQAManager qas; //
-// qas.Run(AliQA::kRAWS, rawROOTFileName); //
-// qas.Run(AliQA::kHITS); //
-// qas.Run(AliQA::kSDIGITS); //
-// qas.Run(AliQA::kDIGITS); //
-// qas.Run(AliQA::kRECPOINTS); //
-// qas.Run(AliQA::kESDS); //
+// qas.Run(AliQAv1::kRAWS, rawROOTFileName); //
+// qas.Run(AliQAv1::kHITS); //
+// qas.Run(AliQAv1::kSDIGITS); //
+// qas.Run(AliQAv1::kDIGITS); //
+// qas.Run(AliQAv1::kRECPOINTS); //
+// qas.Run(AliQAv1::kESDS); //
// //
///////////////////////////////////////////////////////////////////////////////
#include "AliHeader.h"
#include "AliLog.h"
#include "AliModule.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQADataMakerRec.h"
#include "AliQADataMakerSim.h"
#include "AliQAManager.h"
// default ctor
fMaxEvents = fNumberOfEvents ;
for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (IsSelected(AliQA::GetDetName(iDet))) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
fLoader[iDet] = NULL ;
fQADataMaker[iDet] = NULL ;
fQACycles[iDet] = 999999 ;
// default ctor
fMaxEvents = fNumberOfEvents ;
for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (IsSelected(AliQA::GetDetName(iDet))) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
fLoader[iDet] = NULL ;
fQADataMaker[iDet] = NULL ;
fQACycles[iDet] = 999999 ;
{
// dtor
for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (IsSelected(AliQA::GetDetName(iDet))) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
fLoader[iDet] = NULL;
if (fQADataMaker[iDet]) {
(fQADataMaker[iDet])->Finish() ;
}
//_____________________________________________________________________________
-Bool_t AliQAManager::DoIt(const AliQA::TASKINDEX_t taskIndex)
+Bool_t AliQAManager::DoIt(const AliQAv1::TASKINDEX_t taskIndex)
{
// Runs all the QA data Maker for every detector
// Get the event
if ( iEvent%10 == 0 )
AliInfo(Form("processing event %d", iEvent));
- if ( taskIndex == AliQA::kRAWS ) {
+ if ( taskIndex == AliQAv1::kRAWS ) {
if ( !fRawReader->NextEvent() )
break ;
- } else if ( taskIndex == AliQA::kESDS ) {
+ } else if ( taskIndex == AliQAv1::kESDS ) {
if ( fESDTree->GetEntry(iEvent) == 0 )
break ;
} else {
}
// loop over active loaders
for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- if (IsSelected(AliQA::GetDetName(iDet))) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
AliQADataMaker * qadm = GetQADataMaker(iDet) ;
if (!qadm) continue; // This detector doesn't have any QA (for example, HLT)
if ( qadm->IsCycleDone() ) {
TTree * data = NULL ;
AliLoader* loader = GetLoader(qadm->GetUniqueID());
switch (taskIndex) {
- case AliQA::kNULLTASKINDEX :
+ case AliQAv1::kNULLTASKINDEX :
break ;
- case AliQA::kRAWS :
+ case AliQAv1::kRAWS :
qadm->Exec(taskIndex, fRawReader) ;
break ;
- case AliQA::kHITS :
+ case AliQAv1::kHITS :
if( loader ) {
loader->LoadHits() ;
data = loader->TreeH() ;
if ( ! data ) {
- AliWarning(Form(" Hit Tree not found for %s", AliQA::GetDetName(iDet))) ;
+ AliWarning(Form(" Hit Tree not found for %s", AliQAv1::GetDetName(iDet))) ;
break ;
}
}
qadm->Exec(taskIndex, data) ;
break ;
- case AliQA::kSDIGITS :
+ case AliQAv1::kSDIGITS :
if( loader ) {
loader->LoadSDigits() ;
data = loader->TreeS() ;
if ( ! data ) {
- AliWarning(Form(" SDigit Tree not found for %s", AliQA::GetDetName(iDet))) ;
+ AliWarning(Form(" SDigit Tree not found for %s", AliQAv1::GetDetName(iDet))) ;
break ;
}
}
qadm->Exec(taskIndex, data) ;
break;
- case AliQA::kDIGITS :
+ case AliQAv1::kDIGITS :
if( loader ) {
loader->LoadDigits() ;
data = loader->TreeD() ;
if ( ! data ) {
- AliWarning(Form(" Digit Tree not found for %s", AliQA::GetDetName(iDet))) ;
+ AliWarning(Form(" Digit Tree not found for %s", AliQAv1::GetDetName(iDet))) ;
break ;
}
}
qadm->Exec(taskIndex, data) ;
break;
- case AliQA::kRECPOINTS :
+ case AliQAv1::kRECPOINTS :
if( loader ) {
loader->LoadRecPoints() ;
data = loader->TreeR() ;
if (!data) {
- AliWarning(Form("RecPoints not found for %s", AliQA::GetDetName(iDet))) ;
+ AliWarning(Form("RecPoints not found for %s", AliQAv1::GetDetName(iDet))) ;
break ;
}
}
qadm->Exec(taskIndex, data) ;
break;
- case AliQA::kTRACKSEGMENTS :
+ case AliQAv1::kTRACKSEGMENTS :
break;
- case AliQA::kRECPARTICLES :
+ case AliQAv1::kRECPARTICLES :
break;
- case AliQA::kESDS :
+ case AliQAv1::kESDS :
qadm->Exec(taskIndex, fESD) ;
break;
- case AliQA::kNTASKINDEX :
+ case AliQAv1::kNTASKINDEX :
break;
} //task switch
}
// Save QA data for all detectors
rv = Finish(taskIndex) ;
- if ( taskIndex == AliQA::kRAWS )
+ if ( taskIndex == AliQAv1::kRAWS )
fRawReader->RewindEvents() ;
return rv ;
}
//_____________________________________________________________________________
-Bool_t AliQAManager::Finish(const AliQA::TASKINDEX_t taskIndex)
+Bool_t AliQAManager::Finish(const AliQAv1::TASKINDEX_t taskIndex)
{
// write output to file for all detectors
for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- if (IsSelected(AliQA::GetDetName(iDet))) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
AliQADataMaker * qadm = GetQADataMaker(iDet) ;
if (qadm)
qadm->EndOfCycle(taskIndex) ;
}
//_____________________________________________________________________________
-TObjArray * AliQAManager::GetFromOCDB(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, const char * year) const
+TObjArray * AliQAManager::GetFromOCDB(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, const char * year) const
{
// Retrieve the list of QA data for a given detector and a given task
TObjArray * rv = NULL ;
- if ( !strlen(AliQA::GetQARefStorage()) ) {
- AliError("No storage defined, use AliQA::SetQARefStorage") ;
+ if ( !strlen(AliQAv1::GetQARefStorage()) ) {
+ AliError("No storage defined, use AliQAv1::SetQARefStorage") ;
return NULL ;
}
if ( ! IsDefaultStorageSet() ) {
- TString tmp(AliQA::GetQARefDefaultStorage()) ;
+ TString tmp(AliQAv1::GetQARefDefaultStorage()) ;
tmp.Append(year) ;
tmp.Append("/") ;
Instance()->SetDefaultStorage(tmp.Data()) ;
- Instance()->SetSpecificStorage(Form("%s/*", AliQA::GetQAName()), AliQA::GetQARefStorage()) ;
+ Instance()->SetSpecificStorage(Form("%s/*", AliQAv1::GetQAName()), AliQAv1::GetQARefStorage()) ;
}
- TString detOCDBDir(Form("%s/%s/%s", AliQA::GetQAName(), AliQA::GetDetName((Int_t)det), AliQA::GetRefOCDBDirName())) ;
- AliInfo(Form("Retrieving reference data from %s/%s for %s", AliQA::GetQARefStorage(), detOCDBDir.Data(), AliQA::GetTaskName(task).Data())) ;
+ TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetQAName(), AliQAv1::GetDetName((Int_t)det), AliQAv1::GetRefOCDBDirName())) ;
+ AliInfo(Form("Retrieving reference data from %s/%s for %s", AliQAv1::GetQARefStorage(), detOCDBDir.Data(), AliQAv1::GetTaskName(task).Data())) ;
AliCDBEntry* entry = QAManager()->Get(detOCDBDir.Data(), 0) ; //FIXME 0 --> Run Number
TList * listDetQAD = dynamic_cast<TList *>(entry->GetObject()) ;
if ( listDetQAD )
- rv = dynamic_cast<TObjArray *>(listDetQAD->FindObject(AliQA::GetTaskName(task))) ;
+ rv = dynamic_cast<TObjArray *>(listDetQAD->FindObject(AliQAv1::GetTaskName(task))) ;
return rv ;
}
{
// get the loader for a detector
- if ( !fRunLoader || iDet == AliQA::kCORR)
+ if ( !fRunLoader || iDet == AliQAv1::kCORR)
return NULL ;
- TString detName = AliQA::GetDetName(iDet) ;
+ TString detName = AliQAv1::GetDetName(iDet) ;
fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
if (fLoader[iDet])
return fLoader[iDet] ;
}
//_____________________________________________________________________________
-AliQA * AliQAManager::GetQA(UInt_t run, UInt_t evt)
+AliQAv1 * AliQAManager::GetQA(UInt_t run, UInt_t evt)
{
// retrieves the QA object stored in a file named "Run{run}.Event{evt}_1.ESD.tag.root"
char * fileName = Form("Run%d.Event%d_1.ESD.tag.root", run, evt) ;
AliRunTag * tag = new AliRunTag ;
tagTree->SetBranchAddress("AliTAG", &tag) ;
tagTree->GetEntry(evt) ;
- AliQA * qa = AliQA::Instance(tag->GetQALength(), tag->GetQAArray(), tag->GetESLength(), tag->GetEventSpecies()) ;
+ AliQAv1 * qa = AliQAv1::Instance(tag->GetQALength(), tag->GetQAArray(), tag->GetESLength(), tag->GetEventSpecies()) ;
tagFile->Close() ;
return qa ;
}
AliQADataMaker * qadm = NULL ;
- if (iDet == AliQA::kGLOBAL) { //Global QA
+ if (iDet == AliQAv1::kGLOBAL) { //Global QA
qadm = new AliGlobalQADataMaker();
- qadm->SetName(AliQA::GetDetName(iDet));
+ qadm->SetName(AliQAv1::GetDetName(iDet));
qadm->SetUniqueID(iDet);
fQADataMaker[iDet] = qadm;
qadm->SetEventSpecie(fEventSpecie) ;
return qadm;
}
- if (iDet == AliQA::kCORR) { //the data maker for correlations among detectors
+ if (iDet == AliQAv1::kCORR) { //the data maker for correlations among detectors
qadm = new AliCorrQADataMakerRec(fQADataMaker) ;
- qadm->SetName(AliQA::GetDetName(iDet));
+ qadm->SetName(AliQAv1::GetDetName(iDet));
qadm->SetUniqueID(iDet);
fQADataMaker[iDet] = qadm;
qadm->SetEventSpecie(fEventSpecie) ;
// load the QA data maker object
TPluginManager* pluginManager = gROOT->GetPluginManager() ;
- TString detName = AliQA::GetDetName(iDet) ;
+ TString detName = AliQAv1::GetDetName(iDet) ;
TString tmp(fMode) ;
if (tmp.Contains("sim"))
tmp.ReplaceAll("s", "S") ;
qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0) ;
}
if (qadm) {
- qadm->SetName(AliQA::GetDetName(iDet));
+ qadm->SetName(AliQAv1::GetDetName(iDet));
qadm->SetUniqueID(iDet);
fQADataMaker[iDet] = qadm ;
qadm->SetEventSpecie(fEventSpecie) ;
// End of cycle QADataMakers
for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- if (IsSelected(AliQA::GetDetName(iDet))) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
AliQADataMaker * qadm = GetQADataMaker(iDet) ;
if (!qadm)
continue ;
// skip non active detectors
if (detArray) {
- AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQA::GetDetName(iDet))) ;
+ AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQAv1::GetDetName(iDet))) ;
if (!det || !det->IsActive())
continue ;
}
- for (UInt_t taskIndex = 0; taskIndex < AliQA::kNTASKINDEX; taskIndex++) {
+ for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
if ( fTasks.Contains(Form("%d", taskIndex)) )
- qadm->EndOfCycle(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex))) ;
+ qadm->EndOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex))) ;
}
qadm->Finish();
}
// End of cycle QADataMakers
for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- if (IsSelected(AliQA::GetDetName(iDet))) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
AliQADataMaker * qadm = GetQADataMaker(iDet) ;
if (!qadm)
continue ;
// skip non active detectors
- if (!detectors.Contains(AliQA::GetDetName(iDet)))
+ if (!detectors.Contains(AliQAv1::GetDetName(iDet)))
continue ;
- for (UInt_t taskIndex = 0; taskIndex < AliQA::kNTASKINDEX; taskIndex++) {
+ for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
if ( fTasks.Contains(Form("%d", taskIndex)) )
- qadm->EndOfCycle(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex))) ;
+ qadm->EndOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex))) ;
}
qadm->Finish();
}
{
// Increments the cycle counter for all QA Data Makers
for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- if (IsSelected(AliQA::GetDetName(iDet))) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
AliQADataMaker * qadm = GetQADataMaker(iDet) ;
if (qadm)
qadm->Increment() ;
}
//_____________________________________________________________________________
-Bool_t AliQAManager::InitQA(const AliQA::TASKINDEX_t taskIndex, const char * input )
+Bool_t AliQAManager::InitQA(const AliQAv1::TASKINDEX_t taskIndex, const char * input )
{
// Initialize the event source and QA data makers
fTasks += Form("%d", taskIndex) ;
- if (taskIndex == AliQA::kRAWS) {
+ if (taskIndex == AliQAv1::kRAWS) {
if (!fRawReader) {
fRawReader = AliRawReader::Create(input);
}
fNumberOfEvents = 999999 ;
if ( fMaxEvents < 0 )
fMaxEvents = fNumberOfEvents ;
- } else if (taskIndex == AliQA::kESDS) {
- fTasks = AliQA::GetTaskName(AliQA::kESDS) ;
+ } else if (taskIndex == AliQAv1::kESDS) {
+ fTasks = AliQAv1::GetTaskName(AliQAv1::kESDS) ;
if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
TFile * esdFile = TFile::Open("AliESDs.root") ;
fESDTree = dynamic_cast<TTree *> (esdFile->Get("esdTree")) ;
{
// Initializes The QADataMaker for all active detectors and for all active tasks
for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- if (IsSelected(AliQA::GetDetName(iDet))) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
AliQADataMaker * qadm = GetQADataMaker(iDet) ;
if (!qadm) {
- AliError(Form("AliQADataMaker not found for %s", AliQA::GetDetName(iDet))) ;
- fDetectorsW.ReplaceAll(AliQA::GetDetName(iDet), "") ;
+ AliError(Form("AliQADataMaker not found for %s", AliQAv1::GetDetName(iDet))) ;
+ fDetectorsW.ReplaceAll(AliQAv1::GetDetName(iDet), "") ;
} else {
if (fQAWriteExpert[iDet])
qadm->SetWriteExpert() ;
AliDebug(1, Form("Data Maker found for %s %d", qadm->GetName(), qadm->WriteExpert())) ;
// skip non active detectors
if (detArray) {
- AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQA::GetDetName(iDet))) ;
+ AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQAv1::GetDetName(iDet))) ;
if (!det || !det->IsActive())
continue ;
}
// Set default reco params
Bool_t sameCycle = kFALSE ;
- for (UInt_t taskIndex = 0; taskIndex < AliQA::kNTASKINDEX; taskIndex++) {
+ for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
if ( fTasks.Contains(Form("%d", taskIndex)) ) {
- qadm->Init(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex)), GetQACycles(qadm->GetUniqueID())) ;
- qadm->StartOfCycle(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex)), run, sameCycle) ;
+ qadm->Init(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), GetQACycles(qadm->GetUniqueID())) ;
+ qadm->StartOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), run, sameCycle) ;
sameCycle = kTRUE ;
}
}
// load all base libraries to get the loader classes
TString libs = gSystem->GetLibraries() ;
for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(AliQA::GetDetName(iDet)))
+ if (!IsSelected(AliQAv1::GetDetName(iDet)))
continue ;
- TString detName = AliQA::GetDetName(iDet) ;
+ TString detName = AliQAv1::GetDetName(iDet) ;
if (detName == "HLT")
continue;
if (libs.Contains("lib" + detName + "base.so"))
Bool_t rv = kFALSE;
const TString detName(det) ;
// always activates Correlation
- if ( detName.Contains(AliQA::GetDetName(AliQA::kCORR))) {
+ if ( detName.Contains(AliQAv1::GetDetName(AliQAv1::kCORR))) {
rv = kTRUE ;
} else {
// check if all detectors are selected
}
nextRun.Reset() ;
Int_t runNumber = 0 ;
- TFile mergedFile(Form("Merged.%s.Data.root", AliQA::GetQADataFileName()), "RECREATE") ;
+ TFile mergedFile(Form("Merged.%s.Data.root", AliQAv1::GetQADataFileName()), "RECREATE") ;
TH1I * hisRun = new TH1I("hLMR", "List of merged runs", hiRun-loRun+10, loRun, hiRun+10) ;
// create the structure into the merged file
- for (Int_t iDet = 0; iDet < AliQA::kNDET ; iDet++) {
- TDirectory * detDir = mergedFile.mkdir(AliQA::GetDetName(iDet)) ;
- for (Int_t taskIndex = 0; taskIndex < AliQA::kNTASKINDEX; taskIndex++) {
+ for (Int_t iDet = 0; iDet < AliQAv1::kNDET ; iDet++) {
+ TDirectory * detDir = mergedFile.mkdir(AliQAv1::GetDetName(iDet)) ;
+ for (Int_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
detDir->cd() ;
- TDirectory * taskDir = gDirectory->mkdir(AliQA::GetTaskName(taskIndex)) ;
+ TDirectory * taskDir = gDirectory->mkdir(AliQAv1::GetTaskName(taskIndex)) ;
for (Int_t es = 0 ; es < AliRecoParam::kNSpecies ; es++) {
taskDir->cd() ;
TDirectory * esDir = gDirectory->mkdir(AliRecoParam::GetEventSpecieName(es)) ;
esDir->cd() ;
- gDirectory->mkdir(AliQA::GetExpert()) ;
+ gDirectory->mkdir(AliQAv1::GetExpert()) ;
}
}
}
hisRun->Fill(runNumber) ;
AliInfo(Form("Merging run number %d", runNumber)) ;
// search all QA files for runNumber in the current directory
- char * fileList[AliQA::kNDET] ;
+ char * fileList[AliQAv1::kNDET] ;
index = 0 ;
- for (Int_t iDet = 0; iDet < AliQA::kNDET ; iDet++) {
- char * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQA::GetDetName(iDet), AliQA::GetQADataFileName(), runNumber));
+ for (Int_t iDet = 0; iDet < AliQAv1::kNDET ; iDet++) {
+ char * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQAv1::GetDetName(iDet), AliQAv1::GetQADataFileName(), runNumber));
if (file)
fileList[index++] = file ;
}
// Merge QA data from all detectors for a given run in one single file
TFileMerger merger ;
- TString outFileName = Form("Merged.%s.Data.root",AliQA::GetQADataFileName()) ;
+ TString outFileName = Form("Merged.%s.Data.root",AliQAv1::GetQADataFileName()) ;
merger.OutputFile(outFileName.Data()) ;
for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- char * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQA::GetDetName(iDet), AliQA::GetQADataFileName(), runNumber));
+ char * file = gSystem->Which(gSystem->WorkingDirectory(), Form("%s.%s.%d.root", AliQAv1::GetDetName(iDet), AliQAv1::GetQADataFileName(), runNumber));
if (file)
merger.AddFile(file) ;
}
// Merge the QA result from all the data chunks in a run
// to be revised whwn it will be used (see MergeData)
TString cmd ;
- cmd = Form(".! ls %s*.root > tempo.txt", AliQA::GetQADataFileName()) ;
+ cmd = Form(".! ls %s*.root > tempo.txt", AliQAv1::GetQADataFileName()) ;
gROOT->ProcessLine(cmd.Data()) ;
ifstream in("tempo.txt") ;
const Int_t chunkMax = 100 ;
TFileMerger merger ;
TString outFileName ;
if (runNumber != -1)
- outFileName = Form("Merged.%s.Result.%d.root",AliQA::GetQADataFileName(),runNumber);
+ outFileName = Form("Merged.%s.Result.%d.root",AliQAv1::GetQADataFileName(),runNumber);
else
- outFileName = Form("Merged.%s.Result.root",AliQA::GetQADataFileName());
+ outFileName = Form("Merged.%s.Result.root",AliQAv1::GetQADataFileName());
merger.OutputFile(outFileName.Data()) ;
for (Int_t ifile = 0 ; ifile < index ; ifile++) {
TString file = fileList[ifile] ;
// Reset the default data members
for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- if (IsSelected(AliQA::GetDetName(iDet))) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
AliQADataMaker * qadm = GetQADataMaker(iDet);
qadm->Reset();
}
}
if (!fCycleSame)
- if ( !InitQA(AliQA::kRAWS) )
+ if ( !InitQA(AliQAv1::kRAWS) )
return kFALSE ;
fRawReaderDelete = kFALSE ;
- DoIt(AliQA::kRAWS) ;
+ DoIt(AliQAv1::kRAWS) ;
return fDetectorsW ;
}
}
if (!fCycleSame)
- if ( !InitQA(AliQA::kRAWS, fileName) )
+ if ( !InitQA(AliQAv1::kRAWS, fileName) )
return kFALSE ;
- DoIt(AliQA::kRAWS) ;
+ DoIt(AliQAv1::kRAWS) ;
return fDetectorsW ;
}
//_____________________________________________________________________________
-TString AliQAManager::Run(const char * detectors, const AliQA::TASKINDEX_t taskIndex, Bool_t const sameCycle, const char * fileName )
+TString AliQAManager::Run(const char * detectors, const AliQAv1::TASKINDEX_t taskIndex, Bool_t const sameCycle, const char * fileName )
{
// Runs all the QA data Maker for every detector
}
- if ( taskIndex == AliQA::kNULLTASKINDEX) {
- for (UInt_t task = 0; task < AliQA::kNTASKINDEX; task++) {
+ if ( taskIndex == AliQAv1::kNULLTASKINDEX) {
+ for (UInt_t task = 0; task < AliQAv1::kNTASKINDEX; task++) {
if ( fTasks.Contains(Form("%d", task)) ) {
if (!fCycleSame)
- if ( !InitQA(AliQA::GetTaskIndex(AliQA::GetTaskName(task)), fileName) )
+ if ( !InitQA(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(task)), fileName) )
return kFALSE ;
- DoIt(AliQA::GetTaskIndex(AliQA::GetTaskName(task))) ;
+ DoIt(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(task))) ;
}
}
} else {
if ( ! rawReader )
return ;
AliCodeTimerAuto("") ;
- if (fTasks.Contains(Form("%d", AliQA::kRAWS))){
+ if (fTasks.Contains(Form("%d", AliQAv1::kRAWS))){
for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(AliQA::GetDetName(iDet)))
+ if (!IsSelected(AliQAv1::GetDetName(iDet)))
continue;
AliQADataMaker *qadm = GetQADataMaker(iDet);
if (!qadm)
if ( qadm->IsCycleDone() ) {
qadm->EndOfCycle() ;
}
- AliCodeTimerStart(Form("running RAW quality assurance data maker for %s", AliQA::GetDetName(iDet)));
+ AliCodeTimerStart(Form("running RAW quality assurance data maker for %s", AliQAv1::GetDetName(iDet)));
qadm->SetEventSpecie(fEventSpecie) ;
- qadm->Exec(AliQA::kRAWS, rawReader) ;
- AliCodeTimerStop(Form("running RAW quality assurance data maker for %s", AliQA::GetDetName(iDet)));
+ qadm->Exec(AliQAv1::kRAWS, rawReader) ;
+ AliCodeTimerStop(Form("running RAW quality assurance data maker for %s", AliQAv1::GetDetName(iDet)));
}
}
}
//Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
AliCodeTimerAuto("") ;
- if (fTasks.Contains(Form("%d", AliQA::kESDS))) {
+ if (fTasks.Contains(Form("%d", AliQAv1::kESDS))) {
for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(AliQA::GetDetName(iDet)))
+ if (!IsSelected(AliQAv1::GetDetName(iDet)))
continue;
AliQADataMaker *qadm = GetQADataMaker(iDet);
if (!qadm)
if ( qadm->IsCycleDone() ) {
qadm->EndOfCycle() ;
}
- AliCodeTimerStart(Form("running ESD quality assurance data maker for %s", AliQA::GetDetName(iDet)));
- qadm->Exec(AliQA::kESDS, esd) ;
- AliCodeTimerStop(Form("running ESD quality assurance data maker for %s", AliQA::GetDetName(iDet)));
+ AliCodeTimerStart(Form("running ESD quality assurance data maker for %s", AliQAv1::GetDetName(iDet)));
+ qadm->Exec(AliQAv1::kESDS, esd) ;
+ AliCodeTimerStop(Form("running ESD quality assurance data maker for %s", AliQAv1::GetDetName(iDet)));
}
}
}
{
// Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
AliCodeTimerAuto("") ;
- if (fTasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
- if (IsSelected(AliQA::GetDetName(det))) {
+ if (fTasks.Contains(Form("%d", AliQAv1::kRECPOINTS))) {
+ if (IsSelected(AliQAv1::GetDetName(det))) {
AliQADataMaker *qadm = GetQADataMaker(det);
if (qadm) {
if ( qadm->IsCycleDone() ) {
qadm->EndOfCycle() ;
}
- AliCodeTimerStart(Form("running RecPoints quality assurance data maker for %s", AliQA::GetDetName(det)));
- qadm->Exec(AliQA::kRECPOINTS, tree) ;
- AliCodeTimerStop(Form("running RecPoints quality assurance data maker for %s", AliQA::GetDetName(det)));
+ AliCodeTimerStart(Form("running RecPoints quality assurance data maker for %s", AliQAv1::GetDetName(det)));
+ qadm->Exec(AliQAv1::kRECPOINTS, tree) ;
+ AliCodeTimerStop(Form("running RecPoints quality assurance data maker for %s", AliQAv1::GetDetName(det)));
}
}
}
{
// take the locasl QA data merge into a single file and save in OCDB
Bool_t rv = kTRUE ;
- TString tmp(AliQA::GetQARefStorage()) ;
+ TString tmp(AliQAv1::GetQARefStorage()) ;
if ( tmp.IsNull() ) {
- AliError("No storage defined, use AliQA::SetQARefStorage") ;
+ AliError("No storage defined, use AliQAv1::SetQARefStorage") ;
return kFALSE ;
}
- if ( !(tmp.Contains(AliQA::GetLabLocalOCDB()) || tmp.Contains(AliQA::GetLabAliEnOCDB())) ) {
- AliError(Form("%s is a wrong storage, use %s or %s", AliQA::GetQARefStorage(), AliQA::GetLabLocalOCDB().Data(), AliQA::GetLabAliEnOCDB().Data())) ;
+ if ( !(tmp.Contains(AliQAv1::GetLabLocalOCDB()) || tmp.Contains(AliQAv1::GetLabAliEnOCDB())) ) {
+ AliError(Form("%s is a wrong storage, use %s or %s", AliQAv1::GetQARefStorage(), AliQAv1::GetLabLocalOCDB().Data(), AliQAv1::GetLabAliEnOCDB().Data())) ;
return kFALSE ;
}
TString sdet(detectors) ;
rv = Merge(runNumber) ;
if ( ! rv )
return kFALSE ;
- TString inputFileName(Form("Merged.%s.Data.%d.root", AliQA::GetQADataFileName(), runNumber)) ;
+ TString inputFileName(Form("Merged.%s.Data.%d.root", AliQAv1::GetQADataFileName(), runNumber)) ;
inputFile = TFile::Open(inputFileName.Data()) ;
rv = SaveIt2OCDB(runNumber, inputFile, year, es) ;
} else {
- for (Int_t index = 0; index < AliQA::kNDET; index++) {
- if (sdet.Contains(AliQA::GetDetName(index))) {
- TString inputFileName(Form("%s.%s.%d.root", AliQA::GetDetName(index), AliQA::GetQADataFileName(), runNumber)) ;
+ for (Int_t index = 0; index < AliQAv1::kNDET; index++) {
+ if (sdet.Contains(AliQAv1::GetDetName(index))) {
+ TString inputFileName(Form("%s.%s.%d.root", AliQAv1::GetDetName(index), AliQAv1::GetQADataFileName(), runNumber)) ;
inputFile = TFile::Open(inputFileName.Data()) ;
rv *= SaveIt2OCDB(runNumber, inputFile, year, es) ;
}
{
// reads the TH1 from file and adds it to appropriate list before saving to OCDB
Bool_t rv = kTRUE ;
- AliInfo(Form("Saving TH1s in %s to %s", inputFile->GetName(), AliQA::GetQARefStorage())) ;
+ AliInfo(Form("Saving TH1s in %s to %s", inputFile->GetName(), AliQAv1::GetQARefStorage())) ;
if ( ! IsDefaultStorageSet() ) {
- TString tmp( AliQA::GetQARefStorage() ) ;
- if ( tmp.Contains(AliQA::GetLabLocalOCDB()) )
- Instance()->SetDefaultStorage(AliQA::GetQARefStorage()) ;
+ TString tmp( AliQAv1::GetQARefStorage() ) ;
+ if ( tmp.Contains(AliQAv1::GetLabLocalOCDB()) )
+ Instance()->SetDefaultStorage(AliQAv1::GetQARefStorage()) ;
else {
- TString tmp1(AliQA::GetQARefDefaultStorage()) ;
+ TString tmp1(AliQAv1::GetQARefDefaultStorage()) ;
tmp1.Append(year) ;
tmp1.Append("?user=alidaq") ;
Instance()->SetDefaultStorage(tmp1.Data()) ;
}
}
- Instance()->SetSpecificStorage("*", AliQA::GetQARefStorage()) ;
+ Instance()->SetSpecificStorage("*", AliQAv1::GetQARefStorage()) ;
if(GetRun() < 0)
Instance()->SetRun(runNumber);
AliCDBMetaData mdr ;
mdr.SetResponsible("yves schutz");
- for ( Int_t detIndex = 0 ; detIndex < AliQA::kNDET ; detIndex++) {
- TDirectory * detDir = inputFile->GetDirectory(AliQA::GetDetName(detIndex)) ;
+ for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++) {
+ TDirectory * detDir = inputFile->GetDirectory(AliQAv1::GetDetName(detIndex)) ;
if ( detDir ) {
AliInfo(Form("Entering %s", detDir->GetName())) ;
- AliQA::SetQARefDataDirName(es) ;
- TString detOCDBDir(Form("%s/%s/%s", AliQA::GetDetName(detIndex), AliQA::GetRefOCDBDirName(), AliQA::GetRefDataDirName())) ;
+ AliQAv1::SetQARefDataDirName(es) ;
+ TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetDetName(detIndex), AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName())) ;
AliCDBId idr(detOCDBDir.Data(), runNumber, AliCDBRunRange::Infinity()) ;
TList * listDetQAD = new TList() ;
- TString listName(Form("%s QA data Reference", AliQA::GetDetName(detIndex))) ;
- mdr.SetComment(Form("%s QA stuff", AliQA::GetDetName(detIndex)));
+ TString listName(Form("%s QA data Reference", AliQAv1::GetDetName(detIndex))) ;
+ mdr.SetComment(Form("%s QA stuff", AliQAv1::GetDetName(detIndex)));
listDetQAD->SetName(listName) ;
TList * taskList = detDir->GetListOfKeys() ;
TIter nextTask(taskList) ;
if ( !odata ) {
AliError(Form("%s in %s/%s returns a NULL pointer !!", histKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
} else {
- if ( AliQA::GetExpert() == histKey->GetName() ) {
+ if ( AliQAv1::GetExpert() == histKey->GetName() ) {
TDirectory * expertDir = esDir->GetDirectory(histKey->GetName()) ;
TList * expertHistList = expertDir->GetListOfKeys() ;
TIter nextExpertHist(expertHistList) ;
//_____________________________________________________________________________
void AliQAManager::SetEventSpecie(AliRecoParam::EventSpecie_t es)
{
- // set the current event specie and inform AliQA that this event specie has been encountered
+ // set the current event specie and inform AliQAv1 that this event specie has been encountered
fEventSpecie = es ;
- AliQA::Instance()->SetEventSpecie(es) ;
+ AliQAv1::Instance()->SetEventSpecie(es) ;
}
//_____________________________________________________________________________
{
// enable the writing of QA expert data
for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (IsSelected(AliQA::GetDetName(iDet)))
+ if (IsSelected(AliQAv1::GetDetName(iDet)))
fQAWriteExpert[iDet] = kTRUE ;
}
}
// class for running the QA makers //
// //
// AliQAManager qas; //
-// qas.Run(AliQA::kRAWS, rawROOTFileName); //
-// qas.Run(AliQA::kHITS); //
-// qas.Run(AliQA::kSDIGITS); //
-// qas.Run(AliQA::kDIGITS); //
-// qas.Run(AliQA::kRECPOINTS); //
-// qas.Run(AliQA::kESDS); //
+// qas.Run(AliQAv1::kRAWS, rawROOTFileName); //
+// qas.Run(AliQAv1::kHITS); //
+// qas.Run(AliQAv1::kSDIGITS); //
+// qas.Run(AliQAv1::kDIGITS); //
+// qas.Run(AliQAv1::kRECPOINTS); //
+// qas.Run(AliQAv1::kESDS); //
// //
///////////////////////////////////////////////////////////////////////////////
#include <TNamed.h>
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliLoader.h"
#include "AliCDBManager.h"
#include "AliRecoParam.h"
void EndOfCycle(TObjArray * detArray=0x0) ;
void EndOfCycle(TString detectors) ;
UInt_t GetCurrentEvent() const { return fCurrentEvent ; }
- TObjArray * GetFromOCDB(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, const char * year) const ;
- AliQA * GetQA(UInt_t run, UInt_t evt) ;
+ TObjArray * GetFromOCDB(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, const char * year) const ;
+ AliQAv1 * GetQA(UInt_t run, UInt_t evt) ;
AliQADataMaker * GetQADataMaker(const Int_t iDet) ;
void Increment() ;
void InitQADataMaker(UInt_t run, TObjArray * detArray=0x0) ;
Bool_t MergeXML(const char * collection, const char * subFile = 0, const char * outFile = 0) ;
static AliQAManager * QAManager(const Char_t * mode="", TMap *entryCache = NULL, Int_t run = -1) ;
void Reset(const Bool_t sameCycle = kFALSE) ;
- TString Run(const char * detectors, const AliQA::TASKINDEX_t taskIndex=AliQA::kNULLTASKINDEX, Bool_t const sameCycle = kFALSE, const char * fileName = NULL) ;
+ TString Run(const char * detectors, const AliQAv1::TASKINDEX_t taskIndex=AliQAv1::kNULLTASKINDEX, Bool_t const sameCycle = kFALSE, const char * fileName = NULL) ;
TString Run(const char * detectors, AliRawReader * rawReader, Bool_t const sameCycle = kFALSE) ;
TString Run(const char * detectors, const char * filename, Bool_t const sameCycle = kFALSE) ;
void RunOneEvent(AliRawReader * rawReader) ;
void RunOneEvent(AliESDEvent *& esd) ;
Bool_t Save2OCDB(const Int_t runNumber, AliRecoParam::EventSpecie_t es, const char * year = "08", const char * detectors = "ALL") const ;
void SetActiveDetectors(TString aDet) { fDetectors = aDet ; }
- void SetCycleLength(const AliQA::DETECTORINDEX_t det, const Int_t cycle) { fQACycles[det] = cycle ; }
- void SetWriteExpert(const AliQA::DETECTORINDEX_t det) { fQAWriteExpert[det] = kTRUE ; }
+ void SetCycleLength(const AliQAv1::DETECTORINDEX_t det, const Int_t cycle) { fQACycles[det] = cycle ; }
+ void SetWriteExpert(const AliQAv1::DETECTORINDEX_t det) { fQAWriteExpert[det] = kTRUE ; }
void SetEventRange(UInt_t first, UInt_t last) { fFirstEvent = first ; fMaxEvents = last - first + 1 ; }
void SetEventSpecie(AliRecoParam::EventSpecie_t es) ;
void SetFirsEvent(UInt_t first) { fFirstEvent = first ; }
void SetTasks(TString tasks) { fTasks = tasks ; }
void SetWriteExpert() ;
private:
- Bool_t DoIt(const AliQA::TASKINDEX_t taskIndex) ;
+ Bool_t DoIt(const AliQAv1::TASKINDEX_t taskIndex) ;
AliLoader * GetLoader(Int_t iDet) ;
Int_t GetQACycles(const Int_t iDet) const { return fQACycles[iDet] ; }
- Bool_t InitQA(const AliQA::TASKINDEX_t taskIndex, const char * fileName = NULL) ;
+ Bool_t InitQA(const AliQAv1::TASKINDEX_t taskIndex, const char * fileName = NULL) ;
Bool_t InitRunLoader() ;
Bool_t IsSelected(const char * detName) ;
- Bool_t Finish(const AliQA::TASKINDEX_t taskIndex) ;
+ Bool_t Finish(const AliQAv1::TASKINDEX_t taskIndex) ;
Bool_t MergeData(const Int_t runNumber) const ;
Bool_t MergeResults(const Int_t runNumber) const ;
Bool_t SaveIt2OCDB(const Int_t runNumber, TFile * inputFile, const char * year, AliRecoParam::EventSpecie_t es) const ;
Bool_t fRawReaderDelete ; //! tells if the rawReader has been created by this
AliRunLoader * fRunLoader ; //! current run loader object
TString fTasks ; //! list of QA tasks to be performed
- static const UInt_t fgkNDetectors = AliQA::kNDET ; //! number of detectors
+ static const UInt_t fgkNDetectors = AliQAv1::kNDET ; //! number of detectors
AliLoader * fLoader[fgkNDetectors]; //! array of detectors loader
AliQADataMaker * fQADataMaker[fgkNDetectors]; //! array of QA data maker objects
Int_t fQACycles[fgkNDetectors]; //! array of QA cycle length
--- /dev/null
+
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+/* $Id: AliQAv1.cxx 31503 2009-03-16 11:01:16Z schutz $ */
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Quality Assurance Object//_________________________________________________________________________
+// Quality Assurance object. The QA status is held in one word per detector,
+// each bit corresponds to a different status.
+// bit 0-3 : QA raised during simulation (RAW)
+// bit 4-7 : QA raised during simulation (SIM)
+// bit 8-11 : QA raised during reconstruction (REC)
+// bit 12-15 : QA raised during ESD checking (ESD)
+// bit 16-19 : QA raised during analysis (ANA)
+// Each of the 4 bits corresponds to a severity level of increasing importance
+// from lower to higher bit (INFO, WARNING, ERROR, FATAL)
+//
+//*-- Yves Schutz CERN, July 2007
+//////////////////////////////////////////////////////////////////////////////
+
+
+#include <cstdlib>
+// --- ROOT system ---
+#include <TFile.h>
+#include <TSystem.h>
+#include <TROOT.h>
+
+// --- Standard library ---
+
+// --- AliRoot header files ---
+#include "AliLog.h"
+#include "AliQAv1.h"
+
+
+ClassImp(AliQAv1)
+AliQAv1 * AliQAv1::fgQA = 0x0 ;
+TFile * AliQAv1::fgQADataFile = 0x0 ;
+TString AliQAv1::fgQADataFileName = "QA" ; // will transform into Det.QA.run.root
+TFile * AliQAv1::fgQARefFile = 0x0 ;
+TString AliQAv1::fgQARefDirName = "" ;
+TString AliQAv1::fgQARefFileName = "QA.root" ;
+TFile * AliQAv1::fgQAResultFile = 0x0 ;
+TString AliQAv1::fgQAResultDirName = "" ;
+TString AliQAv1::fgQAResultFileName = "QA.root" ;
+TString AliQAv1::fgDetNames[] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD",
+ "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT", "Global", "CORR"} ;
+TString AliQAv1::fgGRPPath = "GRP/GRP/Data" ;
+TString AliQAv1::fgTaskNames[] = {"Raws", "Hits", "SDigits", "Digits", "RecPoints", "TrackSegments", "RecParticles", "ESDs"} ;
+const TString AliQAv1::fgkLabLocalFile = "file://" ;
+const TString AliQAv1::fgkLabLocalOCDB = "local://" ;
+const TString AliQAv1::fgkLabAliEnOCDB = "alien://" ;
+const TString AliQAv1::fgkRefFileName = "QA.root" ;
+const TString AliQAv1::fgkQAName = "QA" ;
+const TString AliQAv1::fgkQACorrNtName = "CorrQA" ;
+const TString AliQAv1::fgkRefOCDBDirName = "QA" ;
+TString AliQAv1::fgRefDataDirName = "" ;
+const TString AliQAv1::fgkQARefOCDBDefault = "alien://folder=/alice/QA/20" ;
+const TString AliQAv1::fgkExpert = "Expert" ;
+const UInt_t AliQAv1::fgkExpertBit = 16 ;
+const UInt_t AliQAv1::fgkQABit = 17 ;
+
+//____________________________________________________________________________
+AliQAv1::AliQAv1() :
+ TNamed("", ""),
+ fNdet(kNDET),
+ fNEventSpecies(AliRecoParam::kNSpecies),
+ fLengthQA(fNdet*fNEventSpecies),
+ fQA(new ULong_t[fLengthQA]),
+ fDet(kNULLDET),
+ fTask(kNULLTASK),
+ fEventSpecie(AliRecoParam::kDefault),
+ fEventSpecies(new Bool_t[fNEventSpecies])
+{
+ // default constructor
+ memset(fQA,0,fLengthQA*sizeof(ULong_t));
+ memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+}
+
+//____________________________________________________________________________
+AliQAv1::AliQAv1(const AliQAv1& qa) :
+ TNamed(qa),
+ fNdet(qa.fNdet),
+ fNEventSpecies(qa.fNEventSpecies),
+ fLengthQA(qa.fLengthQA),
+ fQA(new ULong_t[fLengthQA]),
+ fDet(qa.fDet),
+ fTask(qa.fTask),
+ fEventSpecie(qa.fEventSpecie),
+ fEventSpecies(new Bool_t[fNEventSpecies])
+{
+ // cpy ctor
+ memcpy(fQA,qa.fQA,fLengthQA*sizeof(ULong_t));
+ memcpy(fEventSpecies,qa.fEventSpecies,fNEventSpecies*sizeof(Bool_t));
+}
+
+//_____________________________________________________________________________
+AliQAv1& AliQAv1::operator = (const AliQAv1& qa)
+{
+ // assignment operator
+ if(&qa != this) {
+ TNamed::operator=(qa);
+ fNdet = qa.fNdet;
+ fNEventSpecies = qa.fNEventSpecies;
+ fLengthQA = qa.fLengthQA;
+
+ if(fQA) delete [] fQA;
+ fQA = new ULong_t[fLengthQA];
+ memcpy(fQA,qa.fQA,fLengthQA*sizeof(ULong_t));
+
+ fDet = qa.fDet;
+ fTask = qa.fTask;
+ fEventSpecie = qa.fEventSpecie;
+ if(fEventSpecies) delete [] fEventSpecies;
+ fEventSpecies = new Bool_t[fNEventSpecies];
+ memcpy(fEventSpecies,qa.fEventSpecies,fNEventSpecies*sizeof(Bool_t));
+ }
+ return *this;
+}
+
+//_______________________________________________________________
+AliQAv1::AliQAv1(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es) :
+TNamed("QA", "Quality Assurance status"),
+fNdet(kNDET),
+fNEventSpecies(eslength),
+fLengthQA(qalength),
+fQA(new ULong_t[fLengthQA]),
+fDet(kNULLDET),
+fTask(kNULLTASK),
+fEventSpecie(AliRecoParam::kDefault),
+fEventSpecies(new Bool_t[fNEventSpecies])
+{
+ // constructor to be used
+ memcpy(fQA, qa, fLengthQA*sizeof(ULong_t));
+ memcpy(fEventSpecies, es, fNEventSpecies*sizeof(Bool_t));
+}
+
+//_______________________________________________________________
+AliQAv1::AliQAv1(const DETECTORINDEX_t det) :
+ TNamed("QA", "Quality Assurance status"),
+ fNdet(kNDET),
+ fNEventSpecies(AliRecoParam::kNSpecies),
+ fLengthQA(fNdet*fNEventSpecies),
+ fQA(new ULong_t[fLengthQA]),
+ fDet(det),
+ fTask(kNULLTASK),
+ fEventSpecie(AliRecoParam::kDefault),
+ fEventSpecies(new Bool_t[fNEventSpecies])
+{
+ // constructor to be used
+ if (! CheckRange(det) ) fDet = kNULLDET ;
+ memset(fQA,0,fLengthQA*sizeof(ULong_t));
+ memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+}
+
+//_______________________________________________________________
+AliQAv1::AliQAv1(const ALITASK_t tsk) :
+ TNamed("QA", "Quality Assurance status"),
+ fNdet(kNDET),
+ fNEventSpecies(AliRecoParam::kNSpecies),
+ fLengthQA(fNdet*fNEventSpecies),
+ fQA(new ULong_t[fLengthQA]),
+ fDet(kNULLDET),
+ fTask(tsk),
+ fEventSpecie(AliRecoParam::kDefault),
+ fEventSpecies(new Bool_t[fNEventSpecies])
+{
+ // constructor to be used in the AliRoot module (SIM, REC, ESD or ANA)
+ if (! CheckRange(tsk) ) fTask = kNULLTASK ;
+ memset(fQA,0,fLengthQA*sizeof(ULong_t));
+ memset(fEventSpecies,kFALSE,fNEventSpecies*sizeof(Bool_t));
+}
+
+//____________________________________________________________________________
+AliQAv1::~AliQAv1()
+{
+ // dtor
+ delete [] fQA;
+ delete [] fEventSpecies;
+}
+
+//_______________________________________________________________
+void AliQAv1::Close()
+{
+ // close the open files
+ if (fgQADataFile)
+ if (fgQADataFile->IsOpen())
+ fgQADataFile->Close() ;
+ if (fgQAResultFile)
+ if (fgQAResultFile->IsOpen())
+ fgQAResultFile->Close() ;
+ if (fgQARefFile)
+ if (fgQARefFile->IsOpen())
+ fgQARefFile->Close() ;
+}
+
+//_______________________________________________________________
+Bool_t AliQAv1::CheckFatal() const
+{
+ // check if any FATAL status is set
+ Bool_t rv = kFALSE ;
+ Int_t index ;
+ for (index = 0; index < kNDET ; index++)
+ rv = rv || IsSet(DETECTORINDEX_t(index), fTask, fEventSpecie, kFATAL) ;
+ return rv ;
+}
+
+//_______________________________________________________________
+Bool_t AliQAv1::CheckRange(DETECTORINDEX_t det) const
+{
+ // check if detector is in given detector range: 0-kNDET
+
+ Bool_t rv = ( det < 0 || det > kNDET ) ? kFALSE : kTRUE ;
+ if (!rv)
+ AliFatal(Form("Detector index %d is out of range: 0 <= index <= %d", det, kNDET)) ;
+ return rv ;
+}
+
+//_______________________________________________________________
+Bool_t AliQAv1::CheckRange(ALITASK_t task) const
+{
+ // check if task is given taskk range: 0:kNTASK
+ Bool_t rv = ( task < kRAW || task > kNTASK ) ? kFALSE : kTRUE ;
+ if (!rv)
+ AliFatal(Form("Module index %d is out of range: 0 <= index <= %d", task, kNTASK)) ;
+ return rv ;
+}
+
+//_______________________________________________________________
+Bool_t AliQAv1::CheckRange(QABIT_t bit) const
+{
+ // check if bit is in given bit range: 0-kNBit
+
+ Bool_t rv = ( bit < 0 || bit > kNBIT ) ? kFALSE : kTRUE ;
+ if (!rv)
+ AliFatal(Form("Status bit %d is out of range: 0 <= bit <= %d", bit, kNBIT)) ;
+ return rv ;
+}
+
+//_______________________________________________________________
+Bool_t AliQAv1::CheckRange(AliRecoParam::EventSpecie_t es) const
+{
+ // check if bit is in given bit range: 0-kNBit
+ Bool_t rv = kFALSE ;
+ switch (es) {
+ case AliRecoParam::kDefault:
+ rv = kTRUE ;
+ break ;
+ case AliRecoParam::kLowMult:
+ rv = kTRUE ;
+ break ;
+ case AliRecoParam::kHighMult:
+ rv = kTRUE ;
+ break ;
+ case AliRecoParam::kCosmic:
+ rv = kTRUE ;
+ break ;
+ case AliRecoParam::kCalib:
+ rv = kTRUE ;
+ break ;
+ }
+ if (!rv)
+ AliFatal(Form("Event Specie %d is not valid", es)) ;
+ return rv ;
+}
+
+//_______________________________________________________________
+const char * AliQAv1::GetAliTaskName(ALITASK_t tsk)
+{
+ // returns the char name corresponding to module index
+ TString tskName ;
+ switch (tsk) {
+ case kNULLTASK:
+ break ;
+ case kRAW:
+ tskName = "RAW" ;
+ break ;
+ case kSIM:
+ tskName = "SIM" ;
+ break ;
+ case kREC:
+ tskName = "REC" ;
+ break ;
+ case kESD:
+ tskName = "ESD" ;
+ break ;
+ case kANA:
+ tskName = "ANA" ;
+ break ;
+ default:
+ tsk = kNULLTASK ;
+ break ;
+ }
+ return tskName.Data() ;
+}
+
+//_______________________________________________________________
+const char * AliQAv1::GetBitName(QABIT_t bit) const
+{
+ // returns the char name corresponding to bit
+ TString bitName ;
+ switch (bit) {
+ case kNULLBit:
+ break ;
+ case kINFO:
+ bitName = "INFO" ;
+ break ;
+ case kWARNING:
+ bitName = "WARNING" ;
+ break ;
+ case kERROR:
+ bitName = "ERROR" ;
+ break ;
+ case kFATAL:
+ bitName = "FATAL" ;
+ break ;
+ default:
+ bit = kNULLBit ;
+ break ;
+ }
+ return bitName.Data() ;
+}
+
+//_______________________________________________________________
+AliQAv1::DETECTORINDEX_t AliQAv1::GetDetIndex(const char * name)
+{
+ // returns the detector index corresponding to a given name
+ TString sname(name) ;
+ DETECTORINDEX_t rv = kNULLDET ;
+ for (Int_t det = 0; det < kNDET ; det++) {
+ if ( GetDetName(det) == sname ) {
+ rv = DETECTORINDEX_t(det) ;
+ break ;
+ }
+ }
+ return rv ;
+}
+
+//_______________________________________________________________
+const char * AliQAv1::GetDetName(Int_t det)
+{
+ // returns the detector name corresponding to a given index (needed in a loop)
+
+ if ( det >= 0 && det < kNDET)
+ return (fgDetNames[det]).Data() ;
+ else
+ return NULL ;
+}
+
+//_______________________________________________________________
+TFile * AliQAv1::GetQADataFile(const char * name, Int_t run)
+{
+ // opens the file to store the detectors Quality Assurance Data Maker results
+ const char * temp = Form("%s.%s.%d.root", name, fgQADataFileName.Data(), run) ;
+ TString opt ;
+ if (! fgQADataFile ) {
+ if (gSystem->AccessPathName(temp))
+ opt = "NEW" ;
+ else
+ opt = "UPDATE" ;
+ fgQADataFile = TFile::Open(temp, opt.Data()) ;
+ } else {
+ if ( strcmp(temp, fgQADataFile->GetName()) != 0 ) {
+ fgQADataFile = dynamic_cast<TFile *>(gROOT->FindObject(temp)) ;
+ if ( !fgQADataFile ) {
+ if (gSystem->AccessPathName(temp))
+ opt = "NEW" ;
+ else
+ opt = "UPDATE" ;
+ fgQADataFile = TFile::Open(temp, opt.Data()) ;
+ }
+ }
+ }
+ return fgQADataFile ;
+}
+
+//_____________________________________________________________________________
+TFile * AliQAv1::GetQADataFile(const char * fileName)
+{
+ // Open if necessary the Data file and return its pointer
+
+ if (!fgQADataFile)
+ if (!fileName)
+ fileName = AliQAv1::GetQADataFileName() ;
+ if (!gSystem->AccessPathName(fileName)) {
+ fgQADataFile = TFile::Open(fileName) ;
+ } else {
+ printf("File %s not found", fileName) ;
+ exit(1) ;
+ }
+ return fgQADataFile ;
+}
+
+//_______________________________________________________________
+TFile * AliQAv1::GetQAResultFile()
+{
+ // opens the file to store the Quality Assurance Data Checker results
+ if (fgQAResultFile)
+ fgQAResultFile->Close() ;
+ fgQAResultFile = 0x0 ;
+// if (!fgQAResultFile) {
+ TString dirName(fgQAResultDirName) ;
+ if ( dirName.Contains(fgkLabLocalFile))
+ dirName.ReplaceAll(fgkLabLocalFile, "") ;
+ TString fileName(dirName + fgQAResultFileName) ;
+ TString opt("") ;
+ if ( !gSystem->AccessPathName(fileName) )
+ opt = "UPDATE" ;
+ else {
+ if ( gSystem->AccessPathName(dirName) )
+ gSystem->mkdir(dirName) ;
+ opt = "NEW" ;
+ }
+ fgQAResultFile = TFile::Open(fileName, opt) ;
+// }
+
+ return fgQAResultFile ;
+}
+
+//_______________________________________________________________
+AliQAv1::TASKINDEX_t AliQAv1::GetTaskIndex(const char * name)
+{
+ // returns the detector index corresponding to a given name
+ TString sname(name) ;
+ TASKINDEX_t rv = kNULLTASKINDEX ;
+ for (Int_t tsk = 0; tsk < kNTASKINDEX ; tsk++) {
+ if ( GetTaskName(tsk) == sname ) {
+ rv = TASKINDEX_t(tsk) ;
+ break ;
+ }
+ }
+ return rv ;
+}
+
+//_______________________________________________________________
+Bool_t AliQAv1::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, Int_t ies, QABIT_t bit) const
+{
+ // Checks is the requested bit is set
+
+ const AliRecoParam::EventSpecie_t es = AliRecoParam::Convert(ies) ;
+ return IsSet(det, tsk, es, bit) ;
+
+}
+
+//_______________________________________________________________
+Bool_t AliQAv1::IsSet(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) const
+{
+ // Checks is the requested bit is set
+
+ CheckRange(det) ;
+ CheckRange(tsk) ;
+ CheckRange(bit) ;
+ CheckRange(es) ;
+
+ ULong_t offset = Offset(tsk) ;
+ ULong_t status = GetStatus(det, es) ;
+ offset+= bit ;
+ status = (status & 1 << offset) != 0 ;
+ return status ;
+}
+
+//_______________________________________________________________
+Bool_t AliQAv1::IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) const
+{
+ // Checks is the requested bit is set
+
+ CheckRange(det) ;
+ CheckRange(tsk) ;
+ CheckRange(es) ;
+
+ ULong_t offset = Offset(tsk) ;
+ ULong_t status = GetStatus(det, es) ;
+ ULong_t st = 0 ;
+ for ( Int_t bit = 0 ; bit < kNBIT ; bit++) {
+ offset+= bit ;
+ st += (status & 1 << offset) != 0 ;
+ }
+ if ( st == 0 )
+ return kFALSE ;
+ else
+ return kTRUE ;
+}
+//_______________________________________________________________
+Bool_t AliQAv1::IsSetAny(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es) const
+{
+ // Checks is the requested bit is set
+
+ CheckRange(det) ;
+ CheckRange(es) ;
+
+ ULong_t status = GetStatus(det, es) ;
+ ULong_t st = 0 ;
+ for ( Int_t tsk = 0 ; tsk < kNTASK ; tsk++) {
+ ULong_t offset = Offset(ALITASK_t(tsk)) ;
+ for ( Int_t bit = 0 ; bit < kNBIT ; bit++) {
+ offset+= bit ;
+ st += (status & 1 << offset) != 0 ;
+ }
+ }
+ if ( st == 0 )
+ return kFALSE ;
+ else
+ return kTRUE ;
+}
+
+//_______________________________________________________________
+AliQAv1 * AliQAv1::Instance()
+{
+ // Get an instance of the singleton. The only authorized way to call the ctor
+
+ if ( ! fgQA) {
+ TFile * f = GetQAResultFile() ;
+ fgQA = dynamic_cast<AliQAv1 *>(f->Get("QA")) ;
+ if ( ! fgQA )
+ fgQA = new AliQAv1() ;
+ }
+ return fgQA ;
+}
+
+//_______________________________________________________________
+AliQAv1 * AliQAv1::Instance(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es)
+{
+ // Get an instance of the singleton. The only authorized way to call the ctor
+
+ if ( ! fgQA)
+ fgQA = new AliQAv1(qalength, qa, eslength, es) ;
+ return fgQA ;
+}
+
+//_______________________________________________________________
+AliQAv1 * AliQAv1::Instance(const DETECTORINDEX_t det)
+{
+ // Get an instance of the singleton. The only authorized way to call the ctor
+
+ if ( ! fgQA) {
+ TFile * f = GetQAResultFile() ;
+ fgQA = dynamic_cast<AliQAv1 *>(f->Get("QA")) ;
+ if ( ! fgQA )
+ fgQA = new AliQAv1(det) ;
+ }
+ fgQA->Set(det) ;
+ return fgQA ;
+}
+
+//_______________________________________________________________
+AliQAv1 * AliQAv1::Instance(const ALITASK_t tsk)
+{
+ // Get an instance of the singleton. The only authorized way to call the ctor
+
+ if ( ! fgQA)
+ switch (tsk) {
+ case kNULLTASK:
+ break ;
+ case kRAW:
+ fgQA = new AliQAv1(tsk) ;
+ break ;
+ case kSIM:
+ fgQA = new AliQAv1(tsk) ;
+ break ;
+ case kREC:
+ printf("fgQA = gAlice->GetQA()") ;
+ break ;
+ case kESD:
+ printf("fgQA = dynamic_cast<AliQAv1 *> (esdFile->Get(\"QA\")") ;
+ break ;
+ case kANA:
+ printf("fgQA = dynamic_cast<AliQAv1 *> (esdFile->Get(\"QA\")") ;
+ break ;
+ case kNTASK:
+ break ;
+ }
+ if (fgQA)
+ fgQA->Set(tsk) ;
+ return fgQA ;
+}
+
+//_______________________________________________________________
+AliQAv1 * AliQAv1::Instance(const TASKINDEX_t tsk)
+{
+ // get an instance of the singleton.
+
+ ALITASK_t index = kNULLTASK ;
+
+ if ( tsk == kRAWS )
+ index = kRAW ;
+ else if (tsk < kDIGITS)
+ index = kSIM ;
+ else if (tsk < kRECPARTICLES)
+ index = kREC ;
+ else if (tsk == kESDS)
+ index = kESD ;
+
+ return Instance(index) ;
+}
+
+//_______________________________________________________________
+void AliQAv1::Merge(TCollection * list) {
+ // Merge the QA resuls in the list into this single AliQAv1 object
+
+ for (Int_t det = 0 ; det < kNDET ; det++) {
+ Set(DETECTORINDEX_t(det)) ;
+ for (Int_t task = 0 ; task < kNTASK ; task++) {
+ Set(ALITASK_t(task)) ;
+ for (Int_t bit = 0 ; bit < kNBIT ; bit++) {
+ TIter next(list) ;
+ AliQAv1 * qa ;
+ while ( (qa = (AliQAv1*)next() ) ) {
+ for (Int_t es = 0 ; es < fNEventSpecies ; es++) {
+ if (qa->IsSet(DETECTORINDEX_t(det), ALITASK_t(task), es, QABIT_t(bit)))
+ Set(QABIT_t(bit), es) ;
+ }
+ } // qa list
+ } // bit
+ } // task
+ } // detector
+}
+
+//_______________________________________________________________
+ULong_t AliQAv1::Offset(ALITASK_t tsk) const
+{
+ // Calculates the bit offset for a given module (SIM, REC, ESD, ANA)
+
+ CheckRange(tsk) ;
+
+ ULong_t offset = 0 ;
+ switch (tsk) {
+ case kNULLTASK:
+ break ;
+ case kRAW:
+ offset+= 0 ;
+ break ;
+ case kSIM:
+ offset+= 4 ;
+ break ;
+ case kREC:
+ offset+= 8 ;
+ break ;
+ case kESD:
+ offset+= 12 ;
+ break ;
+ case kANA:
+ offset+= 16 ;
+ break ;
+ case kNTASK:
+ break ;
+ }
+
+ return offset ;
+}
+
+//_______________________________________________________________
+void AliQAv1::ResetStatus(DETECTORINDEX_t det)
+{
+ // reset the status of det for all event specie
+ for (Int_t es = 0 ; es < fNEventSpecies ; es++)
+ fQA[det*fNdet+es] = 0 ;
+}
+
+//_______________________________________________________________
+void AliQAv1::Set(QABIT_t bit, Int_t ies)
+{
+ // Set the status bit of the current detector in the current module and for the current event specie
+ Set(bit, AliRecoParam::Convert(ies)) ;
+}
+
+//_______________________________________________________________
+void AliQAv1::Set(QABIT_t bit, AliRecoParam::EventSpecie_t es)
+{
+ // Set the status bit of the current detector in the current module and for the current event specie
+
+ SetStatusBit(fDet, fTask, es, bit) ;
+}
+
+//_____________________________________________________________________________
+void AliQAv1::SetQARefStorage(const char * name)
+{
+ // Set the root directory where the QA reference data are stored
+
+ fgQARefDirName = name ;
+ if ( fgQARefDirName.Contains(fgkLabLocalFile) )
+ fgQARefFileName = fgkRefFileName ;
+ else if ( fgQARefDirName.Contains(fgkLabLocalOCDB) )
+ fgQARefFileName = fgkQAName ;
+ else if ( fgQARefDirName.Contains(fgkLabAliEnOCDB) )
+ fgQARefFileName = fgkQAName ;
+
+ else {
+ printf("ERROR: %s is an invalid storage definition\n", name) ;
+ fgQARefDirName = "" ;
+ fgQARefFileName = "" ;
+ }
+ TString tmp(fgQARefDirName) ; // + fgQARefFileName) ;
+ printf("AliQAv1::SetQARefDir: QA references are in %s\n", tmp.Data() ) ;
+}
+
+//_____________________________________________________________________________
+void AliQAv1::SetQAResultDirName(const char * name)
+{
+ // Set the root directory where to store the QA status object
+
+ fgQAResultDirName.Prepend(name) ;
+ printf("AliQAv1::SetQAResultDirName: QA results are in %s\n", fgQAResultDirName.Data()) ;
+ if ( fgQAResultDirName.Contains(fgkLabLocalFile))
+ fgQAResultDirName.ReplaceAll(fgkLabLocalFile, "") ;
+ fgQAResultFileName.Prepend(fgQAResultDirName) ;
+}
+
+//_______________________________________________________________
+void AliQAv1::SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit)
+{
+ // Set the status bit for a given detector and a given task
+
+ CheckRange(det) ;
+ CheckRange(tsk) ;
+ CheckRange(bit) ;
+ CheckRange(es) ;
+
+ ULong_t offset = Offset(tsk) ;
+ ULong_t status = GetStatus(det, es) ;
+ offset+= bit ;
+ status = status | 1 << offset ;
+ SetStatus(det, es, status) ;
+}
+
+//_______________________________________________________________
+void AliQAv1::Show(DETECTORINDEX_t det) const
+{
+ // dispplay the QA status word
+ if ( det == kNULLDET)
+ det = fDet ;
+ for (Int_t ies = 0 ; ies < fNEventSpecies ; ies++) {
+ const Bool_t what = IsEventSpecieSet(ies) ;
+ if ( what )
+ ShowStatus(det, kNULLTASK, AliRecoParam::Convert(ies)) ;
+ }
+}
+
+//_______________________________________________________________
+void AliQAv1::ShowAll() const
+{
+ // dispplay the QA status word
+ Int_t index ;
+ for (index = 0 ; index < kNDET ; index++) {
+ for (Int_t tsk = kRAW ; tsk < kNTASK ; tsk++) {
+ for (Int_t ies = 0 ; ies < fNEventSpecies ; ies++) {
+ const Bool_t what = IsEventSpecieSet(ies) ;
+ if ( what )
+ ShowStatus(DETECTORINDEX_t(index), ALITASK_t(tsk), AliRecoParam::Convert(ies)) ;
+ }
+ }
+ }
+}
+
+//_______________________________________________________________
+void AliQAv1::ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) const
+{
+ // Prints the full QA status of a given detector
+ CheckRange(det) ;
+ CheckRange(es) ;
+ ULong_t status = GetStatus(det, es) ;
+ ULong_t tskStatus[kNTASK] ;
+ tskStatus[kRAW] = status & 0x0000f ;
+ tskStatus[kSIM] = status & 0x000f0 ;
+ tskStatus[kREC] = status & 0x00f00 ;
+ tskStatus[kESD] = status & 0x0f000 ;
+ tskStatus[kANA] = status & 0xf0000 ;
+
+ AliInfo(Form("====> QA Status for %8s %8s raw =0x%x, sim=0x%x, rec=0x%x, esd=0x%x, ana=0x%x", GetDetName(det).Data(), AliRecoParam::GetEventSpecieName(es),
+ tskStatus[kRAW], tskStatus[kSIM], tskStatus[kREC], tskStatus[kESD], tskStatus[kANA] )) ;
+ if (tsk == kNULLTASK) {
+ for (Int_t itsk = kRAW ; itsk < kNTASK ; itsk++) {
+ ShowASCIIStatus(es, det, ALITASK_t(itsk), tskStatus[itsk]) ;
+ }
+ } else {
+ ShowASCIIStatus(es, det, tsk, tskStatus[tsk]) ;
+ }
+}
+
+//_______________________________________________________________
+void AliQAv1::ShowASCIIStatus(AliRecoParam::EventSpecie_t es, DETECTORINDEX_t det, ALITASK_t tsk, const ULong_t status) const
+{
+ // print the QA status in human readable format
+ TString text;
+ for (Int_t bit = kINFO ; bit < kNBIT ; bit++) {
+ if (IsSet(det, tsk, es, QABIT_t(bit))) {
+ text = GetBitName(QABIT_t(bit)) ;
+ text += " " ;
+ }
+ }
+ if (! text.IsNull())
+ printf(" %8s %8s %4s 0x%4lx, Problem signalled: %8s \n", AliRecoParam::GetEventSpecieName(es), GetDetName(det).Data(), GetAliTaskName(tsk), status, text.Data()) ;
+}
+
+//_______________________________________________________________
+void AliQAv1::UnSet(QABIT_t bit, Int_t ies)
+{
+ // UnSet the status bit of the current detector in the current module
+ UnSet(bit, AliRecoParam::Convert(ies)) ;
+}
+
+//_______________________________________________________________
+void AliQAv1::UnSet(QABIT_t bit, AliRecoParam::EventSpecie_t es)
+{
+ // UnSet the status bit of the current detector in the current module
+
+ UnSetStatusBit(fDet, fTask, es, bit) ;
+}
+
+//_______________________________________________________________
+void AliQAv1::UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit)
+{
+ // UnSet the status bit for a given detector and a given task
+
+ CheckRange(det) ;
+ CheckRange(tsk) ;
+ CheckRange(bit) ;
+ CheckRange(es) ;
+
+ ULong_t offset = Offset(tsk) ;
+ ULong_t status = GetStatus(det, es) ;
+ offset+= bit ;
+ status = status & 0 << offset ;
+ SetStatus(det, es, status) ;
+}
--- /dev/null
+#ifndef ALIQAv1_H
+#define ALIQAv1_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id: AliQAv1.h 31503 2009-03-16 11:01:16Z schutz $ */
+
+//
+// Quality Assurance Object
+//
+
+#include <TNamed.h>
+#include <TMath.h>
+class TFile ;
+
+#include "AliLog.h"
+#include "AliRecoParam.h"
+
+class AliQAv1 : public TNamed {
+public:
+
+ enum DETECTORINDEX_t {
+ kNULLDET=-1, kITS, kTPC, kTRD, kTOF, kPHOS, kHMPID, kEMCAL, kMUON, kFMD,
+ kZDC, kPMD, kT0, kVZERO, kACORDE, kHLT, kGLOBAL, kCORR, kNDET};
+ enum ALITASK_t {
+ kNULLTASK=-1, kRAW, kSIM, kREC, kESD, kANA, kNTASK };
+ enum QABIT_t {
+ kNULLBit=-1, kINFO, kWARNING, kERROR, kFATAL, kNBIT };
+ enum TASKINDEX_t {
+ kNULLTASKINDEX=-1, kRAWS, kHITS, kSDIGITS, kDIGITS, kRECPOINTS, kTRACKSEGMENTS, kRECPARTICLES, kESDS, kNTASKINDEX };
+
+ // Creators - destructors
+ AliQAv1(); // beware singleton, not to be used
+ AliQAv1(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es) ;
+ AliQAv1(const ALITASK_t tsk) ;
+ AliQAv1(const DETECTORINDEX_t det) ;
+ AliQAv1(const AliQAv1& qa) ;
+ AliQAv1& operator = (const AliQAv1& qa) ;
+ virtual ~AliQAv1();
+
+ static AliQAv1 * Instance() ;
+ static AliQAv1 * Instance(const Int_t qalength, ULong_t * qa, const Int_t eslength, Bool_t * es) ;
+ static AliQAv1 * Instance(const DETECTORINDEX_t det) ;
+ static AliQAv1 * Instance(const ALITASK_t tsk) ;
+ static AliQAv1 * Instance(const TASKINDEX_t tsk) ;
+ Bool_t CheckFatal() const ;
+ static void Close() ;
+ static const char * GetAliTaskName(ALITASK_t tsk) ;
+ Bool_t * GetEventSpecies() { return fEventSpecies ; }
+ static const TString GetExpert() { return fgkExpert ; }
+ static UInt_t GetExpertBit() { return fgkExpertBit ; }
+ static const TString GetLabLocalFile() { return fgkLabLocalFile ; }
+ static const TString GetLabLocalOCDB() { return fgkLabLocalOCDB ; }
+ static const TString GetLabAliEnOCDB() { return fgkLabAliEnOCDB ; }
+ static DETECTORINDEX_t GetDetIndex(const char * name) ;
+ static const TString GetDetName(DETECTORINDEX_t det) { return fgDetNames[det] ; }
+ static const char * GetDetName(Int_t det) ;
+ static const TString GetGRPPath() { return fgGRPPath ; }
+ ULong_t * GetQA() { return fQA ; }
+ static UInt_t GetQABit() { return fgkQABit ; }
+ static TFile * GetQADataFile(const char * name, Int_t run) ;
+ static TFile * GetQADataFile(const char * fileName) ;
+ static const char * GetQADataFileName(const char * name, Int_t run)
+ {return Form("%s.%s.%d.root", name, fgQADataFileName.Data(), run) ; }
+ static const char * GetQADataFileName() { return fgQADataFileName.Data() ; }
+ static const char * GetQAName() { return fgkQAName ; }
+ static const char * GetQACorrName() { return fgkQACorrNtName ; }
+ static TFile * GetQAResultFile() ;
+ static const char * GetQAResultFileName() { return (fgQAResultDirName + fgQAResultFileName).Data() ; }
+ static const char * GetQARefDefaultStorage() { return fgkQARefOCDBDefault.Data() ; }
+ static const char * GetQARefFileName() { return fgQARefFileName ; }
+ static const char * GetQARefStorage() { return fgQARefDirName.Data() ; }
+ static const char * GetRefOCDBDirName() { return fgkRefOCDBDirName.Data() ; }
+ static const char * GetRefDataDirName() { return fgRefDataDirName.Data() ; }
+ static TASKINDEX_t GetTaskIndex(const char * name) ;
+ static TString GetTaskName(UInt_t tsk) { return fgTaskNames[tsk] ; }
+ Bool_t IsEventSpecieSet(AliRecoParam::EventSpecie_t es) const
+ {Int_t ibit=0; while(es!=1<<ibit) ++ibit; return fEventSpecies[ibit];}
+ Bool_t IsEventSpecieSet(Int_t es) const { return fEventSpecies[es] ; }
+ Bool_t IsSet(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) const ;
+ Bool_t IsSet(DETECTORINDEX_t det, ALITASK_t tsk, Int_t es, QABIT_t bit) const ;
+ Bool_t IsSetAny(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es) const ;
+ Bool_t IsSetAny(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es) const ;
+ void Merge(TCollection * list) ;
+ void Set(QABIT_t bit, AliRecoParam::EventSpecie_t es) ;
+ void Set(QABIT_t bit, Int_t es) ;
+ void SetEventSpecie(AliRecoParam::EventSpecie_t es)
+ {Int_t ibit=0; while(es!=1<<ibit) ++ibit; fEventSpecies[ibit] = kTRUE ; }
+ static void SetQAResultDirName(const char * name) ;
+ static void SetQARefStorage(const char * name) ;
+ static void SetQARefDataDirName(AliRecoParam::EventSpecie_t es) { fgRefDataDirName = AliRecoParam::GetEventSpecieName(es) ; }
+ static void SetQARefDataDirName(Int_t es) { fgRefDataDirName = AliRecoParam::GetEventSpecieName(es) ; }
+ void Show(DETECTORINDEX_t det = kNULLDET) const ;
+ void ShowAll() const ;
+ void ShowStatus(DETECTORINDEX_t det, ALITASK_t tsk=kNULLTASK, AliRecoParam::EventSpecie_t es=AliRecoParam::kDefault) const ;
+ void UnSet(QABIT_t bit, AliRecoParam::EventSpecie_t es) ;
+ void UnSet(QABIT_t bit, Int_t es) ;
+
+private:
+
+ Bool_t CheckRange(DETECTORINDEX_t det) const ;
+ Bool_t CheckRange(ALITASK_t tsk) const ;
+ Bool_t CheckRange(QABIT_t bit) const ;
+ Bool_t CheckRange(AliRecoParam::EventSpecie_t es) const ;
+ const char * GetBitName(QABIT_t bit) const ;
+ ULong_t GetStatus(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es) const { return fQA[det*fNEventSpecies+(Int_t)TMath::Log2(es)] ;}
+ void Finish() const ;
+ ULong_t Offset(ALITASK_t tsk) const ;
+ void ShowASCIIStatus(AliRecoParam::EventSpecie_t es, DETECTORINDEX_t det, ALITASK_t tsk, ULong_t status) const ;
+ void ResetStatus(DETECTORINDEX_t det) ;
+ void Set(DETECTORINDEX_t det) { fDet = det ;}
+ void Set(ALITASK_t tsk) { fTask = tsk ; AliDebug(1, Form("Ready to set QA status in %s", GetAliTaskName(tsk) )) ; }
+ void SetStatus(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es, ULong_t status) { fQA[det*fNEventSpecies+(Int_t)TMath::Log2(es)] = status ; }
+ void SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) ;
+ void UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) ;
+
+ static AliQAv1 * fgQA ; // pointer to the instance of the singleton
+ Int_t fNdet ; // number of detectors
+ Int_t fNEventSpecies ; // number of Event Species (see AliRecoParam)
+ Int_t fLengthQA ; // Auxiliary length of fQA
+ ULong_t * fQA ; //[fLengthQA] the status word 4 bits for SIM, REC, ESD, ANA each
+ DETECTORINDEX_t fDet ; //! the current detector (ITS, TPC, ....)
+ ALITASK_t fTask ; //! the current environment (SIM, REC, ESD, ANA)
+ AliRecoParam::EventSpecie_t fEventSpecie ; //! the current event specie
+ static TString fgDetNames[] ; //! list of detector names
+ static TString fgGRPPath ; //! path of the GRP object in OCDB
+ static TFile * fgQADataFile ; //! the output file where the quality assurance maker store their results
+ static TString fgQADataFileName ; //! the name of the file where the quality assurance maker store their results
+ static TFile * fgQARefFile ; //! the output file where the quality assurance maker store their results
+ static TString fgQARefDirName ; //! name of directory where to find the reference data file
+ static TString fgQARefFileName ; //! file name where to find the reference data
+ static TFile * fgQAResultFile ; //! File where to find the QA result
+ static TString fgQAResultDirName ; //! the location of the output file where the QA results are stored
+ static TString fgQAResultFileName ; //! the output file where the QA results are stored
+ static TString fgRTNames[] ; //! list of Run Type names
+ static TString fgTaskNames[] ; //! list of tasks names
+ static const TString fgkExpert ; //! name for the expert directory
+ static const UInt_t fgkExpertBit ; //! TObject bit identifing the object as "expert"
+ static const TString fgkLabLocalFile ; //! label to identify a file as local
+ static const TString fgkLabLocalOCDB ; //! label to identify a file as local OCDB
+ static const TString fgkLabAliEnOCDB ; //! label to identify a file as AliEn OCDB
+ static const TString fgkRefFileName ; //! name of Reference File Name
+ static const UInt_t fgkQABit ; //! bit in the QA data object which is set when Checker does not return 0
+ static const TString fgkQAName ; //! name of QA object
+ static const TString fgkQACorrNtName ; //! name of QA Correlation Ntuple
+ static const TString fgkRefOCDBDirName ; //! name of Reference directory name in OCDB
+ static TString fgRefDataDirName ; //! name of Reference directory name in OCDB for data
+ static const TString fgkQARefOCDBDefault ; //! default storage for QA in OCDB
+ Bool_t * fEventSpecies ; //[fNEventSpecies] list of event species encountered in a run
+
+ ClassDef(AliQAv1,2) //ALICE Quality Assurance Object
+};
+#endif
#include "AliMultiplicity.h"
#include "AliPID.h"
#include "AliPlaneEff.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQADataMakerRec.h"
#include "AliQAManager.h"
#include "AliRawEvent.h"
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
}
- for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+ for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
fQACycles[iDet] = 999999 ;
fQAWriteExpert[iDet] = kFALSE ;
}
fTracker[iDet] = NULL;
}
- for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+ for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
fQACycles[iDet] = rec.fQACycles[iDet];
fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
}
delete fTracker[iDet]; fTracker[iDet] = NULL;
}
- for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+ for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
fQACycles[iDet] = rec.fQACycles[iDet];
fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
}
if (fRunQA) {
fQAManager->SetActiveDetectors(fQADetectors) ;
- for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
- fQAManager->SetCycleLength(AliQA::DETECTORINDEX_t(det), fQACycles[det]) ;
- fQAManager->SetWriteExpert(AliQA::DETECTORINDEX_t(det)) ;
+ for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) {
+ fQAManager->SetCycleLength(AliQAv1::DETECTORINDEX_t(det), fQACycles[det]) ;
+ fQAManager->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
}
- if (!fRawReader && fQATasks.Contains(AliQA::kRAWS))
- fQATasks.ReplaceAll(Form("%d",AliQA::kRAWS), "") ;
+ if (!fRawReader && fQATasks.Contains(AliQAv1::kRAWS))
+ fQATasks.ReplaceAll(Form("%d",AliQAv1::kRAWS), "") ;
fQAManager->SetTasks(fQATasks) ;
fQAManager->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ;
}
if (fRunGlobalQA) {
Bool_t sameCycle = kFALSE ;
- AliQADataMaker *qadm = fQAManager->GetQADataMaker(AliQA::kGLOBAL);
+ AliQADataMaker *qadm = fQAManager->GetQADataMaker(AliQAv1::kGLOBAL);
AliInfo(Form("Initializing the global QA data maker"));
- if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
- qadm->StartOfCycle(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
- TObjArray **arr=qadm->Init(AliQA::kRECPOINTS);
+ if (fQATasks.Contains(Form("%d", AliQAv1::kRECPOINTS))) {
+ qadm->StartOfCycle(AliQAv1::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
+ TObjArray **arr=qadm->Init(AliQAv1::kRECPOINTS);
AliTracker::SetResidualsArray(arr);
sameCycle = kTRUE ;
}
- if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
- qadm->StartOfCycle(AliQA::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
- qadm->Init(AliQA::kESDS);
+ if (fQATasks.Contains(Form("%d", AliQAv1::kESDS))) {
+ qadm->StartOfCycle(AliQAv1::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
+ qadm->Init(AliQAv1::kESDS);
}
}
AliSysInfo::AddStamp("InitQA") ;
// Activate it later within the Run() method
fQARefUri = uri;
- AliQA::SetQARefStorage(fQARefUri.Data()) ;
+ AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
}
//_____________________________________________________________________________
fQAManager->RunOneEvent(fesd) ;
}
if (fRunGlobalQA) {
- AliQADataMaker *qadm = fQAManager->GetQADataMaker(AliQA::kGLOBAL);
+ AliQADataMaker *qadm = fQAManager->GetQADataMaker(AliQAv1::kGLOBAL);
qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
- if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS)))
- qadm->Exec(AliQA::kESDS, fesd);
+ if (qadm && fQATasks.Contains(Form("%d", AliQAv1::kESDS)))
+ qadm->Exec(AliQAv1::kESDS, fesd);
}
if (fWriteESDfriend) {
fQAManager->EndOfCycle() ;
if (fRunGlobalQA) {
- AliQADataMaker *qadm = fQAManager->GetQADataMaker(AliQA::kGLOBAL);
+ AliQADataMaker *qadm = fQAManager->GetQADataMaker(AliQAv1::kGLOBAL);
if (qadm) {
- if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
- qadm->EndOfCycle(AliQA::kRECPOINTS);
- if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
- qadm->EndOfCycle(AliQA::kESDS);
+ if (fQATasks.Contains(Form("%d", AliQAv1::kRECPOINTS)))
+ qadm->EndOfCycle(AliQAv1::kRECPOINTS);
+ if (fQATasks.Contains(Form("%d", AliQAv1::kESDS)))
+ qadm->EndOfCycle(AliQAv1::kESDS);
qadm->Finish();
}
}
AliCodeTimerAuto("");
AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
- esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQA::Instance()->GetQA(), AliQA::Instance()->GetEventSpecies(), AliQA::kNDET, AliRecoParam::kNSpecies);
+ esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
// Cleanup of CDB manager: cache and active storages!
AliCDBManager::Instance()->ClearCache();
// TString newRunTracking ;
// TString newFillESD ;
//
-// for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
-// TString detName(AliQA::GetDetName(iDet)) ;
-// AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ;
-// if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, specie, AliQA::kFATAL)) {
+// for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
+// TString detName(AliQAv1::GetDetName(iDet)) ;
+// AliQAv1 * qa = AliQAv1::Instance(AliQAv1::DETECTORINDEX_t(iDet)) ;
+// if ( qa->IsSet(AliQAv1::DETECTORINDEX_t(iDet), AliQAv1::kSIM, specie, AliQAv1::kFATAL)) {
// AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed",
// detName.Data(), AliRecoParam::GetEventSpecieName(es))) ;
// } else {
-// if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) ||
+// if ( fRunLocalReconstruction.Contains(AliQAv1::GetDetName(iDet)) ||
// fRunLocalReconstruction.Contains("ALL") ) {
// newRunLocalReconstruction += detName ;
// newRunLocalReconstruction += " " ;
// }
-// if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) ||
+// if ( fRunTracking.Contains(AliQAv1::GetDetName(iDet)) ||
// fRunTracking.Contains("ALL") ) {
// newRunTracking += detName ;
// newRunTracking += " " ;
// }
-// if ( fFillESD.Contains(AliQA::GetDetName(iDet)) ||
+// if ( fFillESD.Contains(AliQAv1::GetDetName(iDet)) ||
// fFillESD.Contains("ALL") ) {
// newFillESD += detName ;
// newFillESD += " " ;
fQADetectors = fFillESD ;
fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
if (fQATasks.Contains("ALL") ) {
- fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ;
+ fQATasks = Form("%d %d %d", AliQAv1::kRAWS, AliQAv1::kRECPOINTS, AliQAv1::kESDS) ;
} else {
fQATasks.ToUpper() ;
TString tempo("") ;
if ( fQATasks.Contains("RAW") )
- tempo = Form("%d ", AliQA::kRAWS) ;
+ tempo = Form("%d ", AliQAv1::kRAWS) ;
if ( fQATasks.Contains("RECPOINT") )
- tempo += Form("%d ", AliQA::kRECPOINTS) ;
+ tempo += Form("%d ", AliQAv1::kRECPOINTS) ;
if ( fQATasks.Contains("ESD") )
- tempo += Form("%d ", AliQA::kESDS) ;
+ tempo += Form("%d ", AliQAv1::kESDS) ;
fQATasks = tempo ;
if (fQATasks.IsNull()) {
AliInfo("No QA requested\n") ;
}
}
TString tempo(fQATasks) ;
- tempo.ReplaceAll(Form("%d", AliQA::kRAWS), AliQA::GetTaskName(AliQA::kRAWS)) ;
- tempo.ReplaceAll(Form("%d", AliQA::kRECPOINTS), AliQA::GetTaskName(AliQA::kRECPOINTS)) ;
- tempo.ReplaceAll(Form("%d", AliQA::kESDS), AliQA::GetTaskName(AliQA::kESDS)) ;
+ tempo.ReplaceAll(Form("%d", AliQAv1::kRAWS), AliQAv1::GetTaskName(AliQAv1::kRAWS)) ;
+ tempo.ReplaceAll(Form("%d", AliQAv1::kRECPOINTS), AliQAv1::GetTaskName(AliQAv1::kRECPOINTS)) ;
+ tempo.ReplaceAll(Form("%d", AliQAv1::kESDS), AliQAv1::GetTaskName(AliQAv1::kESDS)) ;
AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
fRunQA = kTRUE ;
return kTRUE;
class AliDetectorRecoParam;
class AliRunInfo;
class AliGRPObject;
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliEventInfo.h"
#include "AliRecoParam.h"
void ImportRunLoader(AliRunLoader* rl) { fRunLoader = rl; }
// Quality Assurance
- void SetQACycles(AliQA::DETECTORINDEX_t det, Int_t cycles) { fQACycles[det] = cycles ; }
- void SetQAWriteExpert(AliQA::DETECTORINDEX_t det) { fQAWriteExpert[det] = kTRUE ; }
+ void SetQACycles(AliQAv1::DETECTORINDEX_t det, Int_t cycles) { fQACycles[det] = cycles ; }
+ void SetQAWriteExpert(AliQAv1::DETECTORINDEX_t det) { fQAWriteExpert[det] = kTRUE ; }
Bool_t SetRunQA(TString detAndAction="ALL:ALL") ;
void SetRunGlobalQA(Bool_t flag=kTRUE){fRunGlobalQA = flag;}
void SetQARefDefaultStorage(const char* uri);
Bool_t fSetRunNumberFromDataCalled; //! flag to check if run number is already loaded from run loader
//Quality Assurance
- Int_t fQACycles[ AliQA::kNDET]; // # events over which QA data are accumulated
- Bool_t fQAWriteExpert[AliQA::kNDET]; // Flag to save or not expert QA data
+ Int_t fQACycles[ AliQAv1::kNDET]; // # events over which QA data are accumulated
+ Bool_t fQAWriteExpert[AliQAv1::kNDET]; // Flag to save or not expert QA data
TString fQADetectors ; // list of detectors to be QA'ed
AliQAManager * fQAManager ; //! steering class to run QA
TString fQATasks ; // list of QA tasks to be performed
// for QA
fQAManager = AliQAManager::QAManager("sim") ;
fQAManager->SetActiveDetectors(fQADetectors) ;
- fQATasks = Form("%d %d %d", AliQA::kHITS, AliQA::kSDIGITS, AliQA::kDIGITS) ;
+ fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ;
fQAManager->SetTasks(fQATasks) ;
}
fQAManager = AliQAManager::QAManager("sim") ;
fQAManager->SetActiveDetectors(fQADetectors) ;
- fQATasks = Form("%d %d %d", AliQA::kHITS, AliQA::kSDIGITS, AliQA::kDIGITS) ;
+ fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ;
fQAManager->SetTasks(fQATasks) ;
if (fWriteQAExpertData)
fQAManager->SetWriteExpert() ;
// Activate it later within the Run() method
fQARefUri = uri;
- AliQA::SetQARefStorage(fQARefUri.Data()) ;
+ AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
}
//_____________________________________________________________________________
fQADetectors = Form("%s %s", fMakeDigits.Data(), fMakeDigitsFromHits.Data()) ;
fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
if (fQATasks.Contains("ALL") ) {
- fQATasks = Form("%d %d %d", AliQA::kHITS, AliQA::kSDIGITS, AliQA::kDIGITS) ;
+ fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ;
} else {
fQATasks.ToUpper() ;
TString tempo("") ;
if ( fQATasks.Contains("HIT") )
- tempo = Form("%d ", AliQA::kHITS) ;
+ tempo = Form("%d ", AliQAv1::kHITS) ;
if ( fQATasks.Contains("SDIGIT") )
- tempo += Form("%d ", AliQA::kSDIGITS) ;
+ tempo += Form("%d ", AliQAv1::kSDIGITS) ;
if ( fQATasks.Contains("DIGIT") )
- tempo += Form("%d ", AliQA::kDIGITS) ;
+ tempo += Form("%d ", AliQAv1::kDIGITS) ;
fQATasks = tempo ;
if (fQATasks.IsNull()) {
AliInfo("No QA requested\n") ;
}
}
TString tempo(fQATasks) ;
- tempo.ReplaceAll(Form("%d", AliQA::kHITS), AliQA::GetTaskName(AliQA::kHITS)) ;
- tempo.ReplaceAll(Form("%d", AliQA::kSDIGITS), AliQA::GetTaskName(AliQA::kSDIGITS)) ;
- tempo.ReplaceAll(Form("%d", AliQA::kDIGITS), AliQA::GetTaskName(AliQA::kDIGITS)) ;
+ tempo.ReplaceAll(Form("%d", AliQAv1::kHITS), AliQAv1::GetTaskName(AliQAv1::kHITS)) ;
+ tempo.ReplaceAll(Form("%d", AliQAv1::kSDIGITS), AliQAv1::GetTaskName(AliQAv1::kSDIGITS)) ;
+ tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITS), AliQAv1::GetTaskName(AliQAv1::kDIGITS)) ;
AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
fRunQA = kTRUE ;
fQAManager->SetActiveDetectors(fQADetectors) ;
fQAManager->SetTasks(fQATasks) ;
- for (Int_t det = 0 ; det < AliQA::kNDET ; det++)
- fQAManager->SetWriteExpert(AliQA::DETECTORINDEX_t(det)) ;
+ for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++)
+ fQAManager->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
return kTRUE;
}
#include <TNamed.h>
#include <TString.h>
#include <TObjArray.h>
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAManager.h"
class AliCDBId;
//Quality Assurance
Int_t GetDetIndex(const char * detector);
- void SetQACycles(AliQA::DETECTORINDEX_t det, const Int_t cycles) { fQAManager->SetCycleLength(det, cycles) ; }
+ void SetQACycles(AliQAv1::DETECTORINDEX_t det, const Int_t cycles) { fQAManager->SetCycleLength(det, cycles) ; }
Bool_t RunQA() ;
Bool_t SetRunQA(TString detAndAction="ALL:ALL") ;
- void SetQAWriteExpert(AliQA::DETECTORINDEX_t det) { fQAManager->SetWriteExpert(det) ; }
+ void SetQAWriteExpert(AliQAv1::DETECTORINDEX_t det) { fQAManager->SetWriteExpert(det) ; }
void SetQARefDefaultStorage(const char* uri);
void InitQA();
void SetEventSpecie(AliRecoParam::EventSpecie_t es) { fEventSpecie = es ; }
AliRelAlignerKalman.cxx
AliESDTagCreator.cxx
AliGRPObject.cxx
-AliQA.cxx
+AliQAv1.cxx
AliRunInfo.cxx AliEventInfo.cxx
AliRecoParam.cxx
AliDetectorRecoParam.cxx
AliPDG.cxx
AliTimeStamp.cxx AliTriggerScalers.cxx AliTriggerScalersRecord.cxx
AliExternalTrackParam.cxx
+ AliQA.cxx
)
# fill list of header files from list of source files
#pragma link C++ class AliTriggerScalersRecord+;
#pragma link C++ class AliExternalTrackParam+;
+#pragma link C++ class AliQA+;
#endif
#pragma link C++ class AliGRPObject+;
-#pragma link C++ class AliQA+;
+#pragma link C++ class AliQAv1+;
#pragma link C++ class AliRunInfo+;
#pragma link C++ class AliEventInfo+;
AliRelAlignerKalman.cxx \
AliESDTagCreator.cxx \
AliGRPObject.cxx \
-AliQA.cxx \
+AliQAv1.cxx \
AliRunInfo.cxx AliEventInfo.cxx \
AliRecoParam.cxx AliDetectorRecoParam.cxx \
AliMillePede2.cxx AliMatrixSq.cxx AliMatrixSparse.cxx AliSymMatrix.cxx AliMinResSolve.cxx
AliCodeTimer.cxx \
AliPDG.cxx \
AliTimeStamp.cxx AliTriggerScalers.cxx AliTriggerScalersRecord.cxx \
- AliExternalTrackParam.cxx
+ AliExternalTrackParam.cxx AliQA.cxx
HDRS:= $(SRCS:.cxx=.h)
// --- AliRoot header files ---
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliT0QAChecker.h"
//____________________________________________________________________________
-Double_t * AliT0QAChecker::Check(AliQA::ALITASK_t /*index*/)
+Double_t * AliT0QAChecker::Check(AliQAv1::ALITASK_t /*index*/)
{
Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
}
//__________________________________________________________________
-Double_t * AliT0QAChecker::Check(AliQA::ALITASK_t index,TObjArray ** list)
+Double_t * AliT0QAChecker::Check(AliQAv1::ALITASK_t index,TObjArray ** list)
{
// Super-basic check on the QA histograms on the input list:
TH1 *fhESD[2];
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- // TString dataType = AliQA::GetAliTaskName(index);
+ // TString dataType = AliQAv1::GetAliTaskName(index);
if (list[specie]->GetEntries() == 0){
test[specie] = 1. ; // nothing to check
}
// dtor
virtual ~AliT0QAChecker() {;}
private:
- virtual Double_t * Check(AliQA::ALITASK_t) ;
- virtual Double_t * Check(AliQA::ALITASK_t, TObjArray ** list) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t, TObjArray ** list) ;
ClassDef(AliT0QAChecker,1) // description
//____________________________________________________________________________
AliT0QADataMaker::AliT0QADataMaker() :
- AliQADataMaker(AliQA::GetDetName(AliQA::kT0), "T0 Quality Assurance Data Maker")
+ AliQADataMaker(AliQAv1::GetDetName(AliQAv1::kT0), "T0 Quality Assurance Data Maker")
{
// ctor
return *this;
}
//____________________________________________________________________________
-void AliT0QADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list)
+void AliT0QADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX task, TObjArray * list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kT0, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kT0, task, list) ;
}
//____________________________________________________________________________
virtual void MakeDigits(TTree* digitsTree) ; //Fill Digit QA histo
virtual void MakeRecPoints(TTree * clusters) ; //Fill cluster QA histo
virtual void MakeESDs(AliESDEvent * esd) ; //Fill hit QA histo
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX, TObjArray * list) ;
virtual void StartOfDetectorCycle() ;
ClassDef(AliT0QADataMaker,1) // description
//____________________________________________________________________________
AliT0QADataMakerRec::AliT0QADataMakerRec() :
-AliQADataMakerRec(AliQA::GetDetName(AliQA::kT0),
+AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kT0),
"T0 Quality Assurance Data Maker"),
fnEvent(0)
return *this;
}
//____________________________________________________________________________
-void AliT0QADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliT0QADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kT0, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kT0, task, list) ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
SetEventSpecie(specie) ;
- if ( task == AliQA::kRAWS ) {
+ if ( task == AliQAv1::kRAWS ) {
const Char_t *triggers[6] = {"mean", "vertex","ORA","ORC","central","semi-central"};
for (Int_t itr=0; itr<6; itr++) {
GetRawsData(197)->Fill(triggers[itr], fNumTriggersCal[itr]);
GetRawsData(207)->GetXaxis()->SetTitle("#PMT");
GetRawsData(207)->GetYaxis()->SetTitle("Charge, #channels");
}
- if ( task == AliQA::kRECPOINTS) {
+ if ( task == AliQAv1::kRECPOINTS) {
GetRecPointsData(0)->SetOption("COLZ");
GetRecPointsData(1)->SetOption("COLZ");
GetRecPointsData(0)->GetXaxis()->SetTitle("#PMT");
virtual void MakeRaws(AliRawReader* rawReader) ;
virtual void MakeRecPoints(TTree * clusters) ; //Fill cluster QA histo
virtual void MakeESDs(AliESDEvent * esd) ; //Fill hit QA histo
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
virtual void StartOfDetectorCycle() ;
Int_t fNumTriggers[6]; //number of trigger signals;
//____________________________________________________________________________
AliT0QADataMakerSim::AliT0QADataMakerSim() :
- AliQADataMakerSim(AliQA::GetDetName(AliQA::kT0), "T0 Quality Assurance Data Maker")
+ AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kT0), "T0 Quality Assurance Data Maker")
{
// ctor
return *this;
}
//____________________________________________________________________________
-void AliT0QADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliT0QADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kT0, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kT0, task, list) ;
}
//____________________________________________________________________________
virtual void MakeHits(TClonesArray *) {} //Dummy for the moment
virtual void MakeDigits(TTree* digitsTree) ; //Fill Digit QA histo
virtual void MakeDigits(TClonesArray *) {} //Dummy for the moment
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
virtual void StartOfDetectorCycle() ;
ClassDef(AliT0QADataMakerSim,1) // description
#include "TObjArray.h"
#include "AliLog.h"
-//#include "AliQA.h"
+//#include "AliQAv1.h"
//#include "AliQAChecker.h"
#include "AliTOFQAChecker.h"
ClassImp(AliTOFQAChecker)
//____________________________________________________________________________
-Double_t * AliTOFQAChecker::Check(AliQA::ALITASK_t /*index*/, TObjArray ** list)
+Double_t * AliTOFQAChecker::Check(AliQAv1::ALITASK_t /*index*/, TObjArray ** list)
{
// Super-basic check on the QA histograms on the input list:
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
test[specie] = 1.0 ;
- if ( !AliQA::Instance()->IsEventSpecieSet(specie) )
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
continue ;
if (list[specie]->GetEntries() == 0){
test[specie] = 0.0 ; // nothing to check
// //
/////////////////////////////////////////////////////////////////////
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQACheckerBase.h"
//class TFile ;
protected:
- virtual Double_t * Check(AliQA::ALITASK_t /*index*/, TObjArray ** list) ;
- virtual Double_t * Check(AliQA::ALITASK_t /*index*/) {return NULL;}
+ virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/, TObjArray ** list) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/) {return NULL;}
ClassDef(AliTOFQAChecker,2) // description
//____________________________________________________________________________
AliTOFQADataMaker::AliTOFQADataMaker() :
- AliQADataMaker(AliQA::GetDetName(AliQA::kTOF), "TOF Quality Assurance Data Maker")
+ AliQADataMaker(AliQAv1::GetDetName(AliQAv1::kTOF), "TOF Quality Assurance Data Maker")
{
//
// ctor
}
//____________________________________________________________________________
-void AliTOFQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list)
+void AliTOFQADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX task, TObjArray * list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kTOF, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kTOF, task, list) ;
}
//____________________________________________________________________________
void AliTOFQADataMaker::GetMapIndeces(Int_t* in , Int_t* out)
virtual void MakeRecPoints(TTree * recTree) ;
virtual void MakeRaws(AliRawReader* rawReader) ;
virtual void StartOfDetectorCycle() ;
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX, TObjArray * list) ;
virtual void GetMapIndeces(Int_t *in, Int_t *out) ;
ClassDef(AliTOFQADataMaker,1) // description
//____________________________________________________________________________
AliTOFQADataMakerRec::AliTOFQADataMakerRec() :
- AliQADataMakerRec(AliQA::GetDetName(AliQA::kTOF), "TOF Quality Assurance Data Maker")
+ AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kTOF), "TOF Quality Assurance Data Maker")
{
//
// ctor
}
//____________________________________________________________________________
-void AliTOFQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliTOFQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kTOF, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kTOF, task, list) ;
}
//____________________________________________________________________________
void AliTOFQADataMakerRec::GetMapIndeces(Int_t* in , Int_t* out)
virtual void MakeRecPoints(TTree * recTree) ;
virtual void MakeRaws(AliRawReader* rawReader) ;
virtual void StartOfDetectorCycle() ;
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) ;
virtual void GetMapIndeces(Int_t *in, Int_t *out) ;
ClassDef(AliTOFQADataMakerRec,1) // description
//____________________________________________________________________________
AliTOFQADataMakerSim::AliTOFQADataMakerSim() :
- AliQADataMakerSim(AliQA::GetDetName(AliQA::kTOF), "TOF Quality Assurance Data Maker")
+ AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kTOF), "TOF Quality Assurance Data Maker")
{
//
// ctor
}
//____________________________________________________________________________
-void AliTOFQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliTOFQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kTOF, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kTOF, task, list) ;
}
//____________________________________________________________________________
void AliTOFQADataMakerSim::GetMapIndeces(Int_t* in , Int_t* out)
virtual void MakeSDigits(TClonesArray * sdigits) ;
virtual void MakeSDigits(TTree * sdigTree);
virtual void StartOfDetectorCycle() ;
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) ;
virtual void GetMapIndeces(Int_t *in, Int_t *out) ;
ClassDef(AliTOFQADataMakerSim,1) // description
//____________________________________________________________________________
AliTPCQADataMakerRec::AliTPCQADataMakerRec() :
- AliQADataMakerRec(AliQA::GetDetName(AliQA::kTPC),
+ AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kTPC),
"TPC Rec Quality Assurance Data Maker"),
fTPCdataQA(NULL)
{
}
//____________________________________________________________________________
-void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if ( !AliQA::Instance()->IsEventSpecieSet(specie) )
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
continue ;
if(fTPCdataQA[specie] != NULL) { // do the final step of the QA for Raw data
}
}
}
- AliQAChecker::Instance()->Run(AliQA::kTPC, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kTPC, task, list) ;
}
//____________________________________________________________________________
private:
virtual void StartOfDetectorCycle() {}; // empty
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray** list) ;
// ESD QA
virtual void InitESDs() ;
//____________________________________________________________________________
AliTPCQADataMakerSim::AliTPCQADataMakerSim() :
- AliQADataMakerSim(AliQA::GetDetName(AliQA::kTPC),
+ AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kTPC),
"TPC Sim Quality Assurance Data Maker")
{
// ctor
}
//____________________________________________________________________________
-void AliTPCQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliTPCQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kTPC, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kTPC, task, list) ;
}
//____________________________________________________________________________
private:
virtual void StartOfDetectorCycle() {}; // empty
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray** list) ;
// Digits QA
virtual void InitDigits();
// --- AliRoot header files ---
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliTRDQAChecker.h"
// --- Standard library ---
// --- AliRoot header files ---
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQACheckerBase.h"
class AliTRDLoader ;
AliTRDQAChecker(const AliTRDQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()) {;} // cpy ctor
virtual ~AliTRDQAChecker() {;} // dtor
- virtual Double_t * Check(AliQA::ALITASK_t /*index*/) {return NULL;}
+ virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/) {return NULL;}
virtual Double_t * Check(TList * /*list*/) {return NULL;}
- virtual Double_t * Check(AliQA::ALITASK_t /*index*/, TObjArray ** /*list*/) {return NULL;}
- virtual Double_t * Check(AliQA::ALITASK_t /*index*/, TNtupleD** /*nt*/) {return NULL;}
+ virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/, TObjArray ** /*list*/) {return NULL;}
+ virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/, TNtupleD** /*nt*/) {return NULL;}
private:
//____________________________________________________________________________
AliTRDQADataMaker::AliTRDQADataMaker() :
- AliQADataMaker(AliQA::GetDetName(AliQA::kTRD), "TRD Quality Assurance Data Maker")
+ AliQADataMaker(AliQAv1::GetDetName(AliQAv1::kTRD), "TRD Quality Assurance Data Maker")
{
//
// Default constructor
}
//____________________________________________________________________________
-void AliTRDQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list)
+void AliTRDQADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX task, TObjArray * list)
{
//
// Detector specific actions at end of cycle
//AliInfo(Form("EndOfCycle", "Fitting RecPoints %d", task))
TH1D *hist = new TH1D("fitHist", "", 200, -0.5, 199.5);
- if (task == AliQA::kRECPOINTS) {
+ if (task == AliQAv1::kRECPOINTS) {
//list->Print();
delete hist;
// call the checker
- AliQAChecker::Instance()->Run(AliQA::kTRD, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kTRD, task, list) ;
//watch.Stop();
//watch.Print();
private:
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray * list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX task, TObjArray * list) ;
virtual void InitHits() ;
virtual void InitESDs() ;
virtual void InitDigits() ;
//____________________________________________________________________________
AliTRDQADataMakerRec::AliTRDQADataMakerRec() :
- AliQADataMakerRec(AliQA::GetDetName(AliQA::kTRD), "TRD Quality Assurance Data Maker")
+ AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kTRD), "TRD Quality Assurance Data Maker")
{
//
// Default constructor
}
//____________________________________________________________________________
-void AliTRDQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliTRDQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//
// Detector specific actions at end of cycle
AliInfo("End of TRD cycle");
- if (task == AliQA::kRECPOINTS) {
+ if (task == AliQAv1::kRECPOINTS) {
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
TH1D * hist = new TH1D("fitHist", "", 200, -0.5, 199.5);
//list[specie]->Print();
// const char *suf[knbits] = {"TPCi", "TPCo", "TPCz", "TRDo", "TRDr", "TRDz"};
//const char *sufRatio[4] = {"TRDrTRDo", "TRDoTPCo", "TRDrTPCo", "TRDzTPCo"};
- if (task == AliQA::kESDS) {
+ if (task == AliQAv1::kESDS) {
const Int_t knRatio = 4;
const Int_t kN[knRatio] = {4,3,4,5};
}
}
// call the checker
- AliQAChecker::Instance()->Run(AliQA::kTRD, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kTRD, task, list) ;
}
//____________________________________________________________________________
private:
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) ;
virtual void InitESDs() ;
virtual void InitRecPoints() ;
virtual void InitRaws() ;
//____________________________________________________________________________
AliTRDQADataMakerSim::AliTRDQADataMakerSim() :
- AliQADataMakerSim(AliQA::GetDetName(AliQA::kTRD), "TRD Quality Assurance Data Maker")
+ AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kTRD), "TRD Quality Assurance Data Maker")
{
//
// Default constructor
}
//____________________________________________________________________________
-void AliTRDQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliTRDQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//
// Detector specific actions at end of cycle
//AliInfo(Form("EndOfCycle", "Fitting RecPoints %d", task));
// call the checker
- AliQAChecker::Instance()->Run(AliQA::kTRD, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kTRD, task, list) ;
}
private:
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) ;
virtual void InitHits() ;
virtual void InitDigits() ;
virtual void InitSDigits() ;
AliInfo("End of TRD cycle");
- //if (task == AliQA::kRECPOINTS) {
+ //if (task == AliQAv1::kRECPOINTS) {
TH1D *hist = new TH1D("fitHist", "", 200, -0.5, 199.5);
//fHist->Print();
// --- AliRoot header files ---
#include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliVZEROQAChecker.h"
#include "AliVZEROQADataMakerRec.h"
ClassImp(AliVZEROQAChecker)
//____________________________________________________________________________
-Double_t * AliVZEROQAChecker::Check(AliQA::ALITASK_t /*index*/)
+Double_t * AliVZEROQAChecker::Check(AliQAv1::ALITASK_t /*index*/)
{
Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
}
//__________________________________________________________________
-Double_t * AliVZEROQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
+Double_t * AliVZEROQAChecker::Check(AliQAv1::ALITASK_t index, TObjArray ** list)
{
// Main check function: Depending on the TASK, different checks will be applied
Double_t * check = new Double_t[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
check[specie] = 1.0 ;
- if ( !AliQA::Instance()->IsEventSpecieSet(specie) )
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
continue ;
if(CheckEntries(list[specie]) == 0.0){
check[specie] = CheckEntries(list[specie]);
} else {
// Check for one disk missing (FATAL) or one ring missing (ERROR) in ESDs
- if(index == AliQA::kESD)
+ if(index == AliQAv1::kESD)
check[specie] = CheckEsds(list[specie]);
}
}
}
//______________________________________________________________________________
-void AliVZEROQAChecker::Init(const AliQA::DETECTORINDEX_t det)
+void AliVZEROQAChecker::Init(const AliQAv1::DETECTORINDEX_t det)
{
// intialises QA and QA checker settings
- AliQA::Instance(det) ;
- Float_t * hiValue = new Float_t[AliQA::kNBIT] ;
- Float_t * lowValue = new Float_t[AliQA::kNBIT] ;
- lowValue[AliQA::kINFO] = 0.5 ;
- hiValue[AliQA::kINFO] = 1.0 ;
- lowValue[AliQA::kWARNING] = 0.2 ;
- hiValue[AliQA::kWARNING] = 0.5 ;
- lowValue[AliQA::kERROR] = 0.0 ;
- hiValue[AliQA::kERROR] = 0.2 ;
- lowValue[AliQA::kFATAL] = -1.0 ;
- hiValue[AliQA::kFATAL] = 0.0 ;
+ AliQAv1::Instance(det) ;
+ Float_t * hiValue = new Float_t[AliQAv1::kNBIT] ;
+ Float_t * lowValue = new Float_t[AliQAv1::kNBIT] ;
+ lowValue[AliQAv1::kINFO] = 0.5 ;
+ hiValue[AliQAv1::kINFO] = 1.0 ;
+ lowValue[AliQAv1::kWARNING] = 0.2 ;
+ hiValue[AliQAv1::kWARNING] = 0.5 ;
+ lowValue[AliQAv1::kERROR] = 0.0 ;
+ hiValue[AliQAv1::kERROR] = 0.2 ;
+ lowValue[AliQAv1::kFATAL] = -1.0 ;
+ hiValue[AliQAv1::kFATAL] = 0.0 ;
SetHiLo(hiValue, lowValue) ;
}
//______________________________________________________________________________
-void AliVZEROQAChecker::SetQA(AliQA::ALITASK_t index, Double_t * value) const
+void AliVZEROQAChecker::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
{
// sets the QA word according to return value of the Check
- AliQA * qa = AliQA::Instance(index);
+ AliQAv1 * qa = AliQAv1::Instance(index);
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- qa->UnSet(AliQA::kFATAL, specie);
- qa->UnSet(AliQA::kWARNING, specie);
- qa->UnSet(AliQA::kERROR, specie);
- qa->UnSet(AliQA::kINFO, specie);
+ qa->UnSet(AliQAv1::kFATAL, specie);
+ qa->UnSet(AliQAv1::kWARNING, specie);
+ qa->UnSet(AliQAv1::kERROR, specie);
+ qa->UnSet(AliQAv1::kINFO, specie);
if ( ! value ) { // No checker is implemented, set all QA to Fatal
- qa->Set(AliQA::kFATAL, specie) ;
+ qa->Set(AliQAv1::kFATAL, specie) ;
} else {
- if ( value[specie] >= fLowTestValue[AliQA::kFATAL] && value[specie] < fUpTestValue[AliQA::kFATAL] )
- qa->Set(AliQA::kFATAL, specie) ;
- else if ( value[specie] > fLowTestValue[AliQA::kERROR] && value[specie] <= fUpTestValue[AliQA::kERROR] )
- qa->Set(AliQA::kERROR, specie) ;
- else if ( value[specie] > fLowTestValue[AliQA::kWARNING] && value[specie] <= fUpTestValue[AliQA::kWARNING] )
- qa->Set(AliQA::kWARNING, specie) ;
- else if ( value[specie] > fLowTestValue[AliQA::kINFO] && value[specie] <= fUpTestValue[AliQA::kINFO] )
- qa->Set(AliQA::kINFO, specie) ;
+ if ( value[specie] >= fLowTestValue[AliQAv1::kFATAL] && value[specie] < fUpTestValue[AliQAv1::kFATAL] )
+ qa->Set(AliQAv1::kFATAL, specie) ;
+ else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] && value[specie] <= fUpTestValue[AliQAv1::kERROR] )
+ qa->Set(AliQAv1::kERROR, specie) ;
+ else if ( value[specie] > fLowTestValue[AliQAv1::kWARNING] && value[specie] <= fUpTestValue[AliQAv1::kWARNING] )
+ qa->Set(AliQAv1::kWARNING, specie) ;
+ else if ( value[specie] > fLowTestValue[AliQAv1::kINFO] && value[specie] <= fUpTestValue[AliQAv1::kINFO] )
+ qa->Set(AliQAv1::kINFO, specie) ;
}
}
}
AliVZEROQAChecker(const AliVZEROQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()) {;} // cpy ctor
virtual ~AliVZEROQAChecker() {;} // destructor
- virtual void Init(const AliQA::DETECTORINDEX_t det) ;
+ virtual void Init(const AliQAv1::DETECTORINDEX_t det) ;
protected:
- virtual Double_t * Check(AliQA::ALITASK_t index, TObjArray ** list);
- virtual Double_t * Check(AliQA::ALITASK_t ) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** list);
+ virtual Double_t * Check(AliQAv1::ALITASK_t ) ;
Double_t CheckEntries(TObjArray * list) const ;
Double_t CheckEsds(TObjArray * list) const;
- virtual void SetQA(AliQA::ALITASK_t index, Double_t * value) const ;
+ virtual void SetQA(AliQAv1::ALITASK_t index, Double_t * value) const ;
private:
//____________________________________________________________________________
AliVZEROQADataMakerRec::AliVZEROQADataMakerRec() :
- AliQADataMakerRec(AliQA::GetDetName(AliQA::kVZERO), "VZERO Quality Assurance Data Maker"),
+ AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kVZERO), "VZERO Quality Assurance Data Maker"),
fCalibData(0x0),
fEvent(0)
//____________________________________________________________________________
-void AliVZEROQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliVZEROQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
// Detector specific actions at end of cycle
// Does the QA checking
- AliQAChecker::Instance()->Run(AliQA::kVZERO, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kVZERO, task, list) ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
SetEventSpecie(specie) ;
- if(task == AliQA::kRAWS){
+ if(task == AliQAv1::kRAWS){
int nMaxBin = GetRawsData(kPedestalTimeInt0)->GetNbinsY();
if(fCurrentCycle%nMaxBin==0) {
GetRawsData(kPedestalTimeInt0)->Reset();
delete hProj;
}
}
- } else if (task == AliQA::kESDS) {
+ } else if (task == AliQAv1::kESDS) {
}
}
}
} // END of SWITCH : EVENT TYPE
fEvent++;
- TParameter<double> * p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kMultiV0A)->GetName()))) ;
+ TParameter<double> * p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiV0A)->GetName()))) ;
p->SetVal((double)mulV0A) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kMultiV0C)->GetName()))) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiV0C)->GetName()))) ;
p->SetVal((double)mulV0C) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kChargeV0A)->GetName()))) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0A)->GetName()))) ;
p->SetVal((double)chargeV0A) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kChargeV0C)->GetName()))) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0C)->GetName()))) ;
p->SetVal((double)chargeV0C) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kChargeV0)->GetName()))) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0)->GetName()))) ;
p->SetVal((double)(chargeV0A + chargeV0C)) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kRawMIPV0A)->GetName()))) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0A)->GetName()))) ;
p->SetVal((double)mipV0A) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kRawMIPV0C)->GetName()))) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0C)->GetName()))) ;
p->SetVal((double)mipV0C) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kRawMIPV0)->GetName()))) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0)->GetName()))) ;
p->SetVal((double)(mipV0A + mipV0C)) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kV0ATime)->GetName()))) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kV0ATime)->GetName()))) ;
p->SetVal((double)timeV0A) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kV0CTime)->GetName()))) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kV0CTime)->GetName()))) ;
p->SetVal((double)timeV0C) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQA::GetTaskName(AliQA::kRAWS).Data(), GetRawsData(kDiffTime)->GetName()))) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kDiffTime)->GetName()))) ;
p->SetVal((double)diffTime) ;
delete rawStream; rawStream = 0x0;
AliVZEROCalibData *fCalibData; //! calibration data
private:
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
virtual void InitESDs() ;
virtual void InitRaws() ;
virtual void MakeESDs(AliESDEvent * esd) ;
//____________________________________________________________________________
AliVZEROQADataMakerSim::AliVZEROQADataMakerSim() :
- AliQADataMakerSim(AliQA::GetDetName(AliQA::kVZERO), "VZERO Quality Assurance Data Maker")
+ AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kVZERO), "VZERO Quality Assurance Data Maker")
{
// constructor
return *this;
}
//____________________________________________________________________________
-void AliVZEROQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliVZEROQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kVZERO, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kVZERO, task, list) ;
}
virtual ~AliVZEROQADataMakerSim() {} // dtor
private:
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t, TObjArray ** list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list);
virtual void InitHits();
virtual void InitDigits();
virtual void MakeHits(TClonesArray* hits) ;
ClassImp(AliZDCQAChecker)
//____________________________________________________________________________
-Double_t * AliZDCQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
+Double_t * AliZDCQAChecker::Check(AliQAv1::ALITASK_t index, TObjArray ** list)
{
// Checks the QA histograms on the input list:
//
Double_t * test = new Double_t[AliRecoParam::kNSpecies] ;
Int_t * ntests = new Int_t[AliRecoParam::kNSpecies] ;
- const char* taskName = AliQA::GetAliTaskName(index);
+ const char* taskName = AliQAv1::GetAliTaskName(index);
//
//YS Int_t beamType=0; // 0 -> protons, 1 -> ions
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
test[specie] = 1.0 ;
ntests[specie] = 0 ;
- if ( !AliQA::Instance()->IsEventSpecieSet(specie) )
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
continue ;
// ====================================================================
// Checks for p-p events
while((hdata = dynamic_cast<TH1 *>(next()))){
if(hdata){
// -------------------------------------------------------------------
- if(index == AliQA::kSIM){
+ if(index == AliQAv1::kSIM){
//AliInfo(Form("\tAliZDCQAChecker-> checking histo %s",hdata->GetName()));
// Check DIGITS histos
if(!(strncmp(hdata->GetName(),"hDig",4))){
}
}
// -------------------------------------------------------------------
- } else if(index == AliQA::kRAW) {
+ } else if(index == AliQAv1::kRAW) {
if(hdata->GetEntries()!=0){
if(hdata->GetMean()>10.)
test[specie] += 1.;
ntests[specie]++;
}
// -------------------------------------------------------------------
- } else if(index == AliQA::kESD) {
+ } else if(index == AliQAv1::kESD) {
Int_t esdInd=0;
if(hdata->GetEntries()!=0){
if(esdInd>1){
Float_t res=0.;
Int_t testgood=0;
// -------------------------------------------------------------------
- if(index == AliQA::kSIM){
+ if(index == AliQAv1::kSIM){
Int_t digInd=0;
// Check DIGITS histos
if (!(strncmp(hdata->GetName(),"hDig",4))){
}
}
// -------------------------------------------------------------------
- else if(index == AliQA::kRAW){
+ else if(index == AliQAv1::kRAW){
Int_t rawInd=0;
// [1] check response of ZNC vs. ZNA
if(rawInd==0 || rawInd==1){
rawInd++;
}
// -------------------------------------------------------------------
- else if(index == AliQA::kESD){
+ else if(index == AliQAv1::kESD){
Double_t eneQZNC, eneQZNA ;
Double_t eneQZPC, eneQZPA ;
Double_t eneCZNC, eneCZNA ;
protected:
- virtual Double_t * Check(AliQA::ALITASK_t index, TObjArray ** list) ;
- virtual Double_t * Check(AliQA::ALITASK_t /*index*/) { return NULL ; }
+ virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** list) ;
+ virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/) { return NULL ; }
ClassDef(AliZDCQAChecker,1) // description
//____________________________________________________________________________
AliZDCQADataMaker::AliZDCQADataMaker() :
- AliQADataMaker(AliQA::GetDetName(AliQA::kZDC), "ZDC Quality Assurance Data Maker"),
+ AliQADataMaker(AliQAv1::GetDetName(AliQAv1::kZDC), "ZDC Quality Assurance Data Maker"),
fHits("AliZDCHit", 1000),
fDigits("AliZDCDigit", 1000)
}
//____________________________________________________________________________
-void AliZDCQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list)
+void AliZDCQADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kZDC, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kZDC, task, list) ;
virtual void MakeRaws(AliRawReader* rawReader);
virtual void MakeESDs(AliESDEvent * esd);
virtual void StartOfDetectorCycle();
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
//
TClonesArray * fHits; //! Array containing ZDC hits
TClonesArray * fDigits; //! Array containing ZDC digits
//____________________________________________________________________________
AliZDCQADataMakerRec::AliZDCQADataMakerRec() :
- AliQADataMakerRec(AliQA::GetDetName(AliQA::kZDC), "ZDC Quality Assurance Data Maker")
+ AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kZDC), "ZDC Quality Assurance Data Maker")
{
// ctor
}
}
//____________________________________________________________________________
-void AliZDCQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
+void AliZDCQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQA::kZDC, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kZDC, task, list) ;
}
virtual void MakeRaws(AliRawReader* rawReader) ;
virtual void MakeESDs(AliESDEvent * esd) ;
virtual void StartOfDetectorCycle() ;
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) ;
ClassDef(AliZDCQADataMakerRec,1) // description
\r
//____________________________________________________________________________ \r
AliZDCQADataMakerSim::AliZDCQADataMakerSim() : \r
- AliQADataMakerSim(AliQA::GetDetName(AliQA::kZDC), "ZDC Quality Assurance Data Maker"),\r
+ AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kZDC), "ZDC Quality Assurance Data Maker"),\r
fHits(0),\r
fDigit(0)\r
{\r
}\r
\r
//____________________________________________________________________________ \r
-void AliZDCQADataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)\r
+void AliZDCQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)\r
{\r
// Detector specific actions at end of cycle\r
// do the QA checking\r
- AliQAChecker::Instance()->Run(AliQA::kZDC, task, list); \r
+ AliQAChecker::Instance()->Run(AliQAv1::kZDC, task, list); \r
}\r
virtual void MakeSDigits(TClonesArray * /*sdigits*/) {;} \r
virtual void MakeSDigits(TTree * /*sdigTree*/) {;}\r
virtual void StartOfDetectorCycle(); \r
- virtual void EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list);\r
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list);\r
//\r
TClonesArray *fHits; //! Array containing ZDC hits\r
AliZDCDigit *fDigit; //! Pointer to digit in tree \r
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff