//_____________________________________________________________________
void AliFMDQADataMakerRec::InitRaws()
{
-
- TH1I* hADCCounts;
- for(Int_t det = 1; det<=3; det++) {
- Int_t firstring = (det==1 ? 1 : 0);
- for(Int_t iring = firstring;iring<=1;iring++) {
- for(Int_t b = 0; b<=1;b++) {
-
- //Hexadecimal board numbers 0x0, 0x1, 0x10, 0x10;
- UInt_t board = (iring == 1 ? 0 : 1);
- board = board + b*16;
- Char_t ring = (iring == 1 ? 'I' : 'O');
-
- hADCCounts = new TH1I(Form("hADCCounts_FMD%d%c_board%d",
- det, ring, board), "ADC counts",
+ TH1I* hADCCounts = new TH1I("hADCCounts","Dist of ADC counts",
1024,0,1023);
- hADCCounts->SetXTitle("ADC counts");
- hADCCounts->SetYTitle("");
- Int_t index = GetHalfringIndex(det, ring, board/16);
- Add2RawsList(hADCCounts, index);
-
- }
- }
- }
+ hADCCounts->SetXTitle("ADC counts");
+ hADCCounts->SetYTitle("");
+ Add2RawsList(hADCCounts, 0);
+
}
//_____________________________________________________________________
digitsAddress->Clear();
fmdReader.ReadAdcs(digitsAddress);
for(Int_t i=0;i<digitsAddress->GetEntriesFast();i++) {
- //Raw ADC counts
- AliFMDDigit* digit = static_cast<AliFMDDigit*>(digitsAddress->At(i));
- UShort_t det = digit->Detector();
- Char_t ring = digit->Ring();
- UShort_t sec = digit->Sector();
- UShort_t strip = digit->Strip();
- UInt_t ddl, board, chip, channel;
- AliFMDParameters* pars = AliFMDParameters::Instance();
- pars->Detector2Hardware(det,ring,sec,strip,ddl,board,chip,channel);
- Int_t index = GetHalfringIndex(det, ring, board/16);
-
- GetRawsData(index)->Fill(digit->Counts());
-
+ //Raw ADC counts
+ AliFMDDigit* digit = static_cast<AliFMDDigit*>(digitsAddress->At(i));
+ GetRawsData(0)->Fill(digit->Counts());
}
}
// do?
}
//_____________________________________________________________________
-Int_t AliFMDQADataMakerRec::GetHalfringIndex(UShort_t det,
- Char_t ring,
- UShort_t board) {
-
- UShort_t iring = (ring == 'I' ? 1 : 0);
-
- Int_t index = (((det-1) << 2) | (iring << 1) | (board << 0));
-
- return index-2;
-
-}
-
-//_____________________________________________________________________
-
-
//
// EOF
//
void AliITSQASSDDataMakerRec::StartOfDetectorCycle()\r
{\r
//Detector specific actions at start of cycle\r
+ \r
+ if ( fAliITSQADataMakerRec->GetRawsData(0) == NULL ) // Raws not defined\r
+ return ; \r
+ \r
AliDebug(1,"AliITSQADM::Start of SSD Cycle\n"); \r
\r
//Data size per DDL\r
void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray* list)\r
{\r
// launch the QA checking\r
+ if ( fAliITSQADataMakerRec->GetRawsData(0) == NULL ) // Raws not defined\r
+ return ; \r
+ \r
AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); \r
//Data size per DDL\r
for(Int_t i = 0; i < fgkNumOfDDLs; i++) {\r
fPedestals->ClassName(),
fGains->ClassName()));
- TString qaFileName(AliQA::GetQADataFileName("MUON",calibData.RunNumber(),0));
+ TString qaFileName(AliQA::GetQADataFileName("MUON",calibData.RunNumber()));
// search the QA file in memory first.
TFile* f = static_cast<TFile*>(gROOT->GetListOfFiles()->FindObject(qaFileName.Data()));
{
//Detector specific actions at end of cycle
// do the QA checking
- if (task == AliQA::kRAWS)
- AliQAChecker::Instance()->Run(AliQA::kCORR, task, fObject) ;
+ if (task == AliQA::kRAWS) {
+ AliQAChecker::Instance()->Run(AliQA::kCORR, task, fObject) ;
+ }
}
//____________________________________________________________________________
}
//____________________________________________________________________________
-void AliCorrQADataMakerRec::MakeRaws()
+void AliCorrQADataMakerRec::MakeRaws(AliRawReader *)
{
//Fill prepared histograms with Raw digit properties
if ( fMaxRawVar > 0 ) {
void AliCorrQADataMakerRec::StartOfDetectorCycle()
{
//Detector specific actions at start of cycle
+
}
AliCorrQADataMakerRec(const AliCorrQADataMakerRec& qadm) ;
AliCorrQADataMakerRec& operator = (const AliCorrQADataMakerRec& qadm) ;
virtual ~AliCorrQADataMakerRec() {;} // dtor
- void MakeRaws() ;
private:
virtual void InitRaws() ;
virtual void MakeESDs(AliESDEvent * esd) ;
virtual void MakeRecPoints(TTree * recpoTree) ;
- virtual void MakeRaws(AliRawReader *) { AliWarning("May not use") ;}
+ virtual void MakeRaws(AliRawReader *) ;
virtual void StartOfDetectorCycle() ;
Int_t fMaxRawVar ; //! number of raw parameters in the ntuple
const TString AliQA::fkgRefOCDBDirName = "Ref" ;
TString AliQA::fkgRefDataDirName = "" ;
const TString AliQA::fkgQARefOCDBDefault = "alien://folder=/alice/QA/20" ;
+
//____________________________________________________________________________
AliQA::AliQA() :
TNamed("", ""),
}
//_______________________________________________________________
-TFile * AliQA::GetQADataFile(const char * name, const Int_t run, const Int_t cycle)
+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.%d.root", name, fgQADataFileName.Data(), run, cycle) ;
+ const char * temp = Form("%s.%s.%d.root", name, fgQADataFileName.Data(), run) ;
TString opt ;
if (! fgQADataFile ) {
if (gSystem->AccessPathName(temp))
static const TString GetDetName(DETECTORINDEX_t det) { return fgDetNames[det] ; }
static const char * GetDetName(Int_t det) ;
static const TString GetGRPPath() { return fgGRPPath ; }
- static TFile * GetQADataFile(const char * name, const Int_t run, const Int_t cycle) ;
+ 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, const Int_t cycle)
- {return Form("%s.%s.%d.%d.root", name, fgQADataFileName.Data(), run, cycle) ; }
+ 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 ; }
protected:
virtual const Double_t Check(AliQA::ALITASK_t index) ;
virtual const Double_t Check(AliQA::ALITASK_t, TObjArray *) ;
- virtual const Double_t Check(AliQA::ALITASK_t, TNtupleD *) {;}
+ virtual const Double_t Check(AliQA::ALITASK_t, TNtupleD *) { return -1.0 ;}
const Double_t DiffC(const TH1 * href, const TH1 * hin) const ;
const Double_t DiffK(const TH1 * href, const TH1 * hin) const ;
void Finish() const ;
fOutput(0x0),
fDetectorDir(0x0),
fDetectorDirName(""),
- fCurrentCycle(-1),
+ fCurrentCycle(0),
fCycle(9999999),
fCycleCounter(0),
fParameterList(0x0),
return NULL ;
}
}
-
-//____________________________________________________________________________
-void AliQADataMaker::Reset(const Bool_t sameCycle)
-{
- // Resets defaut value of data members
- if (!sameCycle) {
- fCycleCounter = 0 ;
- }
-}
virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index) = 0 ;
virtual Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t saveForCorr = kFALSE) = 0 ;
virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index) = 0 ;
- virtual void Exec(AliQA::TASKINDEX_t, TObject * data) = 0 ;
- virtual void EndOfCycle(AliQA::TASKINDEX_t) = 0 ;
+ virtual void Exec(AliQA::TASKINDEX_t, TObject * data) = 0 ;
+ virtual void EndOfCycle() = 0 ;
+ virtual void EndOfCycle(AliQA::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 ; }
const Int_t Increment() { return ++fCycleCounter ; }
- virtual TObjArray * Init(AliQA::TASKINDEX_t, Int_t run, Int_t cycles = -1) = 0 ;
+ 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 ;
const Bool_t IsCycleDone() const { return fCycleCounter > fCycle ? kTRUE : kFALSE ; }
- void Reset(const Bool_t sameCycle = kTRUE) ;
+ void Reset() { fCycleCounter = 0 ; }
void SetCycle(Int_t nevts) { fCycle = nevts ; }
- virtual void StartOfCycle(AliQA::TASKINDEX_t, const Bool_t sameCycle = kFALSE) = 0 ;
+ 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 SetRecoParam(const AliDetectorRecoParam */*param*/) { return; }
return *this;
}
+//____________________________________________________________________________
+void AliQADataMakerRec::EndOfCycle()
+{
+ // Finishes a cycle of QA for all the tasks
+ EndOfCycle(AliQA::kRAWS) ;
+ EndOfCycle(AliQA::kRECPOINTS) ;
+ EndOfCycle(AliQA::kESDS) ;
+ ResetCycle() ;
+}
+
//____________________________________________________________________________
void AliQADataMakerRec::EndOfCycle(AliQA::TASKINDEX_t task)
{
- // Finishes a cycle of QA data acquistion
+ // Finishes a cycle of QA
TObjArray * list = NULL ;
else if ( task == AliQA::kESDS )
list = fESDsQAList ;
- //DefaultEndOfDetectorCycle(task) ;
+
+ if ( ! list && ! fObject )
+ return ;
+ //DefaultEndOfDetectorCycle(task) ;
EndOfDetectorCycle(task, list) ;
TDirectory * subDir = NULL ;
if (fDetectorDir)
subDir->cd() ;
if (list)
list->Write() ;
- if (fObject)
+ if (fObject) {
fObject->Write() ;
+ }
}
- //Finish() ;
}
//____________________________________________________________________________
if (rawReader)
MakeRaws(rawReader) ;
else
- AliError("Wrong data type") ;
+ AliInfo("Raw data are not processed") ;
} else if ( task == AliQA::kRECPOINTS ) {
AliDebug(1, "Processing RecPoints QA") ;
TTree * tree = dynamic_cast<TTree *>(data) ;
}
//____________________________________________________________________________
-TObjArray * AliQADataMakerRec::Init(AliQA::TASKINDEX_t task, Int_t run, Int_t cycles)
+TObjArray * AliQADataMakerRec::Init(AliQA::TASKINDEX_t task, Int_t cycles)
{
// general intialisation
TObjArray * rv = NULL ;
- fRun = run ;
if (cycles > 0)
SetCycle(cycles) ;
}
//____________________________________________________________________________
-void AliQADataMakerRec::StartOfCycle(AliQA::TASKINDEX_t task, const Bool_t sameCycle)
+void AliQADataMakerRec::StartOfCycle(Int_t run)
+{
+ // Finishes a cycle of QA for all the tasks
+ Bool_t samecycle = kFALSE ;
+ StartOfCycle(AliQA::kRAWS, run, samecycle) ;
+ samecycle = kTRUE ;
+ StartOfCycle(AliQA::kRECPOINTS, run, samecycle) ;
+ StartOfCycle(AliQA::kESDS, run, samecycle) ;
+}
+
+//____________________________________________________________________________
+void AliQADataMakerRec::StartOfCycle(AliQA::TASKINDEX_t task, Int_t run, const Bool_t sameCycle)
{
// Finishes a cycle of QA data acquistion
+ if ( run > 0 )
+ fRun = run ;
if ( !sameCycle || fCurrentCycle == -1) {
ResetCycle() ;
if (fOutput)
fOutput->Close() ;
- fOutput = AliQA::GetQADataFile(GetName(), fRun, fCurrentCycle) ;
+ fOutput = AliQA::GetQADataFile(GetName(), fRun) ;
}
AliInfo(Form(" Run %d Cycle %d task %s file %s",
fRun, fCurrentCycle, AliQA::GetTaskName(task).Data(), fOutput->GetName() )) ;
subDir = fDetectorDir->mkdir(AliQA::GetTaskName(task)) ;
subDir->cd() ;
- TObjArray * list = NULL ;
-
- if ( task == AliQA::kRAWS )
- list = fRawsQAList ;
- else if ( task == AliQA::kRECPOINTS)
- list = fRecPointsQAList ;
- else if ( task == AliQA::kESDS )
- list = fESDsQAList ;
-
-// Should be the choice of detectors
-// TIter next(list) ;
-// TH1 * h ;
-// while ( (h = dynamic_cast<TH1 *>(next())) )
-// h->Reset() ;
-
StartOfDetectorCycle() ;
}
virtual Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t saveForCorr = kFALSE) { return Add2List(hist, index, fRawsQAList, saveForCorr) ; }
virtual Int_t Add2SDigitsList(TH1 * /*hist*/, const Int_t /*index*/) { return -1 ; }
virtual void Exec(AliQA::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 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 * GetRawsData(const Int_t index) { return fRawsQAList ? dynamic_cast<TH1 *>(GetData(fRawsQAList, index)) : NULL ; }
virtual TH1 * GetSDigitsData(const Int_t /*index*/) { return NULL ; }
- virtual TObjArray * Init(AliQA::TASKINDEX_t task, Int_t run, Int_t cycles = -1) ;
+ 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 void StartOfCycle(AliQA::TASKINDEX_t task, const Bool_t sameCycle = kFALSE) ;
+ virtual void StartOfCycle(Int_t run = -1) ;
+ virtual void StartOfCycle(AliQA::TASKINDEX_t task, Int_t run, const Bool_t sameCycle = kFALSE) ;
virtual void SetRecoParam(const AliDetectorRecoParam *param) { fRecoParam = param; }
TObjArray * fESDsQAList ; //! list of the ESDs QA data objects
TObjArray * fRawsQAList ; //! list of the raws QA data objects
TObjArray * fRecPointsQAList ; //! list of the RecPoints QA data objects
- TObject * fObject ; //! This is used by Corr only ro hold its Ntuple. Allows to write something else than TH1 to QA data file
+ TObject * fObject ; //! This is used by Corr only to hold its Ntuple. Allows to write something else than TH1 to QA data file
const AliDetectorRecoParam *fRecoParam; //! const pointer to the reco parameters to be used in the reco QA
ClassDef(AliQADataMakerRec,2) // description
return *this;
}
+//____________________________________________________________________________
+void AliQADataMakerSim::EndOfCycle()
+{
+ // Finishes a cycle of QA for all tasks
+ EndOfCycle(AliQA::kHITS) ;
+ EndOfCycle(AliQA::kSDIGITS) ;
+ EndOfCycle(AliQA::kDIGITS) ;
+ ResetCycle() ;
+}
+
//____________________________________________________________________________
void AliQADataMakerSim::EndOfCycle(AliQA::TASKINDEX_t task)
{
list = fSDigitsQAList ;
else if ( task == AliQA::kDIGITS )
list = fDigitsQAList ;
-
+
+ if ( ! list )
+ return ;
EndOfDetectorCycle(task, list) ;
TDirectory * subDir = fDetectorDir->GetDirectory(AliQA::GetTaskName(task)) ;
if (subDir) {
subDir->cd() ;
list->Write() ;
}
+ ResetCycle() ;
}
//____________________________________________________________________________
}
//____________________________________________________________________________
-TObjArray * AliQADataMakerSim::Init(AliQA::TASKINDEX_t task, Int_t run, Int_t cycles)
+TObjArray * AliQADataMakerSim::Init(AliQA::TASKINDEX_t task, Int_t cycles)
{
// general intialisation
- fRun = run ;
if (cycles > 0)
SetCycle(cycles) ;
TObjArray * rv = NULL ;
}
//____________________________________________________________________________
-void AliQADataMakerSim::StartOfCycle(AliQA::TASKINDEX_t task, const Bool_t sameCycle)
+void AliQADataMakerSim::StartOfCycle(Int_t run)
+{
+ // Finishes a cycle of QA for all tasks
+ Bool_t samecycle = kFALSE ;
+ StartOfCycle(AliQA::kHITS, run, samecycle) ;
+ samecycle = kTRUE ;
+ StartOfCycle(AliQA::kSDIGITS, run, samecycle) ;
+ StartOfCycle(AliQA::kDIGITS, run, samecycle) ;
+}
+
+//____________________________________________________________________________
+void AliQADataMakerSim::StartOfCycle(AliQA::TASKINDEX_t task, Int_t run, const Bool_t sameCycle)
{
// Finishes a cycle of QA data acquistion
+ if ( run > 0 )
+ fRun = run ;
if ( !sameCycle || fCurrentCycle == -1) {
ResetCycle() ;
if (fOutput)
fOutput->Close() ;
- fOutput = AliQA::GetQADataFile(GetName(), fRun, fCurrentCycle) ;
+ fOutput = AliQA::GetQADataFile(GetName(), fRun) ;
}
AliInfo(Form(" Run %d Cycle %d task %s file %s",
if (!subDir)
subDir = fDetectorDir->mkdir(AliQA::GetTaskName(task)) ;
subDir->cd() ;
-
- TObjArray * list = 0x0 ;
-
- if ( task == AliQA::kHITS )
- list = fHitsQAList ;
- else if ( task == AliQA::kSDIGITS )
- list = fSDigitsQAList ;
- else if ( task == AliQA::kDIGITS )
- list = fDigitsQAList ;
-
-// Should be the choice of detectors
-// TIter next(list) ;
-// TH1 * h ;
-// while ( (h = dynamic_cast<TH1 *>(next())) )
-// h->Reset() ;
-//
+
StartOfDetectorCycle() ;
}
virtual Int_t Add2RawsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t saveForCorr = kFALSE) { return -1 ; }
virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index) { return Add2List(hist, index, fSDigitsQAList) ; }
virtual void Exec(AliQA::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 TH1 * GetDigitsData(const Int_t index) { return dynamic_cast<TH1 *>(GetData(fDigitsQAList, 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 run, Int_t cycles = -1) ;
+ 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 void StartOfCycle(AliQA::TASKINDEX_t task, const Bool_t sameCycle = kFALSE) ;
+ virtual void StartOfCycle(Int_t run = -1) ;
+ virtual void StartOfCycle(AliQA::TASKINDEX_t task, Int_t run, const Bool_t sameCycle = kFALSE) ;
protected:
if (IsSelected(AliQA::GetDetName(iDet))) {
AliQADataMaker * qadm = GetQADataMaker(iDet) ;
if ( qadm->IsCycleDone() ) {
- qadm->EndOfCycle(AliQA::kRAWS) ;
- qadm->StartOfCycle(AliQA::kRAWS) ;
+ qadm->EndOfCycle(taskIndex) ;
}
TTree * data = NULL ;
AliLoader* loader = GetLoader(qadm->GetUniqueID());
} //task switch
}
} // detector loop
+ Increment() ;
} // event loop
// Save QA data for all detectors
rv = Finish(taskIndex) ;
}
}
+//_____________________________________________________________________________
+void AliQADataMakerSteer::Increment()
+{
+ // Increments the cycle counter for all QA Data Makers
+ for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
+ if (IsSelected(AliQA::GetDetName(iDet))) {
+ AliQADataMaker * qadm = GetQADataMaker(iDet) ;
+ if (qadm)
+ qadm->Increment() ;
+ }
+ }
+}
+
//_____________________________________________________________________________
Bool_t AliQADataMakerSteer::Init(const AliQA::TASKINDEX_t taskIndex, const char * input )
{
if ( ! AliGeomManager::GetGeometry() )
AliGeomManager::LoadGeometry() ;
- InitQADataMaker(fRunNumber, fRecoParam, fCycleSame, kTRUE, detArray) ;
+ InitQADataMaker(fRunNumber, fRecoParam, detArray) ; //, fCycleSame, kTRUE, detArray) ;
return kTRUE ;
}
//_____________________________________________________________________________
-void AliQADataMakerSteer::InitQADataMaker(UInt_t run, const AliRecoParam & par, Bool_t sameCycle, Bool_t startOption, TObjArray * detArray)
+void AliQADataMakerSteer::InitQADataMaker(UInt_t run, const AliRecoParam & par, TObjArray * detArray)
{
// Initializes The QADataMaker for all active detectors and for all active tasks
}
// Set default reco params
qadm->SetRecoParam(par.GetDetRecoParam(iDet));
+ Bool_t sameCycle = kFALSE ;
for (UInt_t taskIndex = 0; taskIndex < AliQA::kNTASKINDEX; taskIndex++) {
if ( fTasks.Contains(Form("%d", taskIndex)) ) {
- qadm->Init(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex)), run, GetQACycles(qadm->GetUniqueID())) ;
- if (startOption) {
- qadm->StartOfCycle(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex)), sameCycle) ;
- sameCycle = kTRUE ;
- }
+ qadm->StartOfCycle(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex)), run, sameCycle) ;
+ qadm->Init(AliQA::GetTaskIndex(AliQA::GetTaskName(taskIndex)), GetQACycles(qadm->GetUniqueID())) ;
+ sameCycle = kTRUE ;
}
}
}
for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
if (IsSelected(AliQA::GetDetName(iDet))) {
AliQADataMaker * qadm = GetQADataMaker(iDet);
- qadm->Reset(sameCycle);
+ qadm->Reset();
}
}
if (fRawReaderDelete) {
void AliQADataMakerSteer::RunOneEvent(AliRawReader * rawReader)
{
//Runs all the QA data Maker for Raws only and on one event only (event loop done by calling method)
-
+ if ( ! rawReader )
+ return ;
AliCodeTimerAuto("") ;
if (fTasks.Contains(Form("%d", AliQA::kRAWS))){
for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
AliQADataMaker *qadm = GetQADataMaker(iDet);
if (!qadm)
continue;
+ if ( qadm->IsCycleDone() ) {
+ qadm->EndOfCycle() ;
+ }
AliCodeTimerStart(Form("running RAW quality assurance data maker for %s", AliQA::GetDetName(iDet)));
qadm->Exec(AliQA::kRAWS, rawReader) ;
AliCodeTimerStop(Form("running RAW quality assurance data maker for %s", AliQA::GetDetName(iDet)));
AliQADataMaker *qadm = GetQADataMaker(iDet);
if (!qadm)
continue;
+ 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)));
// 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 (IsSelected(AliQA::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)));
- }
- }
- }
+ AliCodeTimerStop(Form("running RecPoints quality assurance data maker for %s", AliQA::GetDetName(det)));
+ }
+ }
+ }
}
//_____________________________________________________________________________
UInt_t GetCurrentEvent() const { return fCurrentEvent ; }
TObjArray * GetFromOCDB(AliQA::DETECTORINDEX_t det, AliQA::TASKINDEX_t task, const char * year) const ;
AliQADataMaker * GetQADataMaker(const Int_t iDet) ;
- void InitQADataMaker(UInt_t run, const AliRecoParam & par, Bool_t sameCycle, Bool_t startOption=kTRUE, TObjArray * detArray=0x0) ;
+ void Increment() ;
+ void InitQADataMaker(UInt_t run, const AliRecoParam & par, TObjArray * detArray=0x0) ;
Bool_t Merge(const Int_t runNumber = -1 ) const ;
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) ;
fQATasks("ALL"),
fRunQA(kTRUE),
fRunGlobalQA(kTRUE),
- fInLoopQA(kFALSE),
fSameQACycle(kFALSE),
fRunPlaneEff(kFALSE),
fTracker[iDet] = NULL;
fQACycles[iDet] = 999999;
}
- fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ;
AliPID pid;
}
fQATasks(rec.fQATasks),
fRunQA(rec.fRunQA),
fRunGlobalQA(rec.fRunGlobalQA),
- fInLoopQA(rec.fInLoopQA),
fSameQACycle(rec.fSameQACycle),
fRunPlaneEff(rec.fRunPlaneEff),
for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
}
-
}
//_____________________________________________________________________________
fQATasks = rec.fQATasks;
fRunQA = rec.fRunQA;
fRunGlobalQA = rec.fRunGlobalQA;
- fInLoopQA = rec.fInLoopQA;
fSameQACycle = rec.fSameQACycle;
fRunPlaneEff = rec.fRunPlaneEff;
while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
(fRawReader && fRawReader->NextEvent())) {
if (!ProcessEvent(iEvent)) {
- Abort("ProcessEvent",TSelector::kAbortFile);
- return kFALSE;
+ Abort("ProcessEvent",TSelector::kAbortFile);
+ return kFALSE;
}
iEvent++;
}
AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
//QA
- fQASteer = new AliQADataMakerSteer("rec") ;
- fQASteer->SetActiveDetectors(fQADetectors) ;
- fQASteer->SetTasks(fQATasks) ;
-
- if ( !fInLoopQA ) {
- if (fRunQA && fRawReader && fQATasks.Contains(Form("%d", AliQA::kRAWS))) {
- fQASteer->Run(fQADetectors, fRawReader) ;
- fSameQACycle = kTRUE ;
- }
- }
-
- //Initialize the QA and start of cycle for out-of-loop QA
+ //Initialize the QA and start of cycle
if (fRunQA) {
- fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam, fSameQACycle, !fInLoopQA) ;
+ fQASteer = new AliQADataMakerSteer("rec") ;
+ fQASteer->SetActiveDetectors(fQADetectors) ;
+ for (Int_t det = 0 ; det < fgkNDetectors ; det++)
+ fQASteer->SetCycleLength(AliQA::DETECTORINDEX_t(det), fQACycles[det]) ;
+ if (!fRawReader && fQATasks.Contains(AliQA::kRAWS))
+ fQATasks.ReplaceAll(Form("%d",AliQA::kRAWS), "") ;
+ fQASteer->SetTasks(fQATasks) ;
+ fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam) ;
}
-
+
if (fRunGlobalQA) {
- fSameQACycle = kFALSE;
+ Bool_t sameCycle = kFALSE ;
AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
AliInfo(Form("Initializing the global QA data maker"));
if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
- TObjArray *arr=qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
+ qadm->StartOfCycle(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
+ TObjArray *arr=qadm->Init(AliQA::kRECPOINTS);
AliTracker::SetResidualsArray(arr);
- if (!fInLoopQA) {
- qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
- fSameQACycle = kTRUE;
- }
+ sameCycle = kTRUE ;
}
if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
- qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
- if (!fInLoopQA) {
- qadm->StartOfCycle(AliQA::kESDS, fSameQACycle);
- fSameQACycle = kTRUE;
- }
+ qadm->StartOfCycle(AliQA::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
+ qadm->Init(AliQA::kESDS);
}
}
GetEventInfo();
fRecoParam.SetEventSpecie(fRunInfo,fEventInfo);
- //Start of cycle for the in-loop QA
- if (fInLoopQA && fRunQA) {
- fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam, fSameQACycle, fInLoopQA) ;
- }
- if (fInLoopQA && fRunGlobalQA) {
- fSameQACycle = kFALSE;
- AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
- if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
- qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
- fSameQACycle = kTRUE;
- }
- if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
- qadm->StartOfCycle(AliQA::kESDS, fSameQACycle);
- fSameQACycle = kTRUE;
- }
- }
-
fRunLoader->GetEvent(iEvent);
// QA on single raw
- if (fInLoopQA && fRunQA)
+ if (fRunQA)
fQASteer->RunOneEvent(fRawReader) ;
// local single event reconstruction
gSystem->GetProcInfo(&ProcInfo);
AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
-
- // End of cycle for the in-loop
- if (fInLoopQA && fRunQA) {
- fQASteer->RunOneEvent(fesd) ;
- fQASteer->EndOfCycle() ;
- }
- if (fInLoopQA && fRunGlobalQA) {
- AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::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);
- qadm->Finish();
- }
- }
-
fEventInfo.Reset();
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (fReconstructor[iDet])
fReconstructor[iDet]->SetRecoParam(NULL);
}
+ fQASteer->Increment() ;
return kTRUE;
}
AliWarning("Finish PlaneEff evaluation failed");
}
- //Finish QA and end of cycle for out-of-loop QA
- if (!fInLoopQA && fRunQA)
- fQASteer->Run(fRunLocalReconstruction.Data(), AliQA::kNULLTASKINDEX, fSameQACycle) ;
- if (!fInLoopQA && fRunGlobalQA) {
+ // End of cycle for the in-loop
+ if (fRunQA) {
+ fQASteer->RunOneEvent(fesd) ;
+ fQASteer->EndOfCycle() ;
+ }
+ if (fRunGlobalQA) {
AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
if (qadm) {
if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
- qadm->EndOfCycle(AliQA::kRECPOINTS);
+ qadm->EndOfCycle(AliQA::kRECPOINTS);
if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
- qadm->EndOfCycle(AliQA::kESDS);
+ qadm->EndOfCycle(AliQA::kESDS);
qadm->Finish();
}
}
-
gROOT->cd();
CleanUp();
}
loader->UnloadDigits();
}
- // In-loop QA for local reconstrucion
TString detQAStr(fQADetectors) ;
- if (fRunQA && fInLoopQA)
+ if (fRunQA)
fQASteer->RunOneEventInOneDetector(iDet, clustersTree) ;
loader->WriteRecPoints("OVERWRITE");
class AliRecoParam;
class AliDetectorRecoParam;
class AliRunInfo;
+#include "AliQA.h"
#include "AliEventInfo.h"
#include "AliRecoParam.h"
void ImportRunLoader(AliRunLoader* rl) { fRunLoader = rl; }
// Quality Assurance
- void SetQACycles(const char * detector, const Int_t cycles) { fQACycles[GetDetIndex(detector)] = cycles ; }
+ void SetQACycles(AliQA::DETECTORINDEX_t det, const Int_t cycles) { fQACycles[det] = cycles ; }
Bool_t SetRunQA(TString detAndAction="ALL:ALL") ;
void SetRunGlobalQA(Bool_t flag=kTRUE){fRunGlobalQA = flag;}
- void SetInLoopQA(Bool_t flag=kTRUE) {fInLoopQA = flag;}
// Plane Efficiency Evaluation
void SetRunPlaneEff(Bool_t flag=kFALSE) {fRunPlaneEff = flag;}
void InitRun(const char* input);
void InitRawReader(const char* input);
- void InitCDB();
- Bool_t InitGRP();
- void SetCDBLock();
+ void InitCDB();
+ Bool_t InitGRP();
+ void SetCDBLock();
Bool_t SetRunNumberFromData();
Bool_t LoadCDB();
Bool_t RunLocalEventReconstruction(const TString& detectors);
void FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd);
//Quality Assurance
- const Int_t GetQACycles(const char * detector) { return fQACycles[GetDetIndex(detector)] ; }
void CheckQA() ;
// Plane Efficiency evaluation
TString fQATasks ; // list of QA tasks to be performed
Bool_t fRunQA ; // Run QA flag
Bool_t fRunGlobalQA; // Run global QA flag
- Bool_t fInLoopQA; // In-loop QA flag
Bool_t fSameQACycle; //! open a new QA data file or not
// Plane Efficiency Evaluation
Bool_t fRunPlaneEff ; // Evaluate Plane Efficiency
#include "AliGenEventHeader.h"
#include "AliMC.h"
#include "AliHLTSimulation.h"
-#include "AliQADataMakerSteer.h"
#include "AliSysInfo.h"
#include "AliMagF.h"
SetGAliceFile("galice.root");
// for QA
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++)
- fQACycles[iDet] = 999999;
fQASteer = new AliQADataMakerSteer("sim") ;
fQASteer->SetActiveDetectors(fQADetectors) ;
fQATasks = Form("%d %d %d", AliQA::kHITS, AliQA::kSDIGITS, AliQA::kDIGITS) ;
if (sim.fSpecCDBUri[i]) fSpecCDBUri.Add(sim.fSpecCDBUri[i]->Clone());
}
fgInstance = this;
-
-// for QA
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++)
- fQACycles[iDet] = sim.fQACycles[iDet];
}
//_____________________________________________________________________________
#include <TString.h>
#include <TObjArray.h>
#include "AliQA.h"
+#include "AliQADataMakerSteer.h"
class AliCDBId;
class AliCDBParam;
class AliRunLoader;
-class AliQADataMakerSteer ;
class AliSimulation: public TNamed {
public:
//Quality Assurance
Int_t GetDetIndex(const char * detector);
- const Int_t GetQACycles(const char * detector) { return fQACycles[GetDetIndex(detector)] ; }
- void SetQACycles(const char * detector, const Int_t cycles) { fQACycles[GetDetIndex(detector)] = cycles ; }
+ void SetQACycles(AliQA::DETECTORINDEX_t det, const Int_t cycles) { fQASteer->SetCycleLength(det, cycles) ; }
Bool_t RunQA() ;
Bool_t SetRunQA(TString detAndAction="ALL:ALL") ;
//QA stuff
static const Int_t fgkNDetectors = 15 ; // number of detectors
static const char * fgkDetectorName[fgkNDetectors] ; // names of detectors
- Int_t fQACycles[fgkNDetectors] ; // cycle length (# events) over which QA data are accumulated
TString fQADetectors ; // list of detectors to be QA'ed
TString fQATasks ; // list of QA tasks to be performed
AliQADataMakerSteer * fQASteer ; // steering object to run QA
Int_t iACORDE= 1;
Int_t iDIPO = 1;
Int_t iEMCAL = 1;
- Int_t iFMD = 1;
+ Int_t iFMD = 0;
Int_t iFRAME = 1;
Int_t iHALL = 1;
Int_t iITS = 1;
Int_t iMAG = 1;
- Int_t iMUON = 1;
+ Int_t iMUON = 0;
Int_t iPHOS = 1;
Int_t iPIPE = 1;
Int_t iPMD = 1;
-void rec() {
+ void rec() {
const char * kYear = "08" ;
AliCDBManager * man = AliCDBManager::Instance();
//man->SetDefaultStorage("alien://Folder=/alice/data/2008/LHC08c/OCDB/");
// reco.SetRunReconstruction("ITS TPC TRD TOF HMPID PHOS EMCAL MUON T0 VZERO FMD PMD ZDC ACORDE");
reco.SetRunReconstruction("ITS TPC TRD HMPID PHOS EMCAL MUON T0 VZERO FMD PMD ZDC ACORDE");
reco.SetRunQA("ALL:ALL") ;
- reco.SetInLoopQA() ;
// AliQA::SetQARefStorage(Form("%s%s/", AliQA::GetQARefDefaultStorage(), kYear)) ;
AliQA::SetQARefStorage("local://$ALICE_ROOT") ;
+ for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
+ reco.SetQACycles(det, 2) ;
+ }
+
// **** The field map settings must be the same as in Config.C !
AliMagFMaps *field=new AliMagFMaps("Maps","Maps",2,1.,10.,AliMagFMaps::k5kG);
Bool_t uniform=kFALSE;
// switch off cleanESD
reco.SetCleanESD(kFALSE);
- reco.SetInLoopQA() ;
reco.SetRunQA("ALL:ALL") ;
//AliQA::SetQARefStorage(Form("%s%s/", AliQA::GetQARefDefaultStorage(), kYear)) ;
AliQA::SetQARefStorage("local://$ALICE_ROOT") ;
+ for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
+ reco.SetQACycles(det, 2) ;
+ }
AliLog::Flush();
-void sim(Int_t nev=1) {
+void sim(Int_t nev=4) {
const char * kYear = "08" ;
AliSimulation simu;
- simu.SetMakeSDigits("TRD TOF PHOS HMPID EMCAL MUON FMD PMD T0 ZDC VZERO");
- simu.SetMakeDigits ("TRD TOF PHOS HMPID EMCAL MUON FMD PMD T0 ZDC VZERO");
+// simu.SetMakeSDigits("TRD TOF PHOS HMPID EMCAL MUON FMD PMD T0 ZDC VZERO");
+ simu.SetMakeSDigits("TRD TOF PHOS HMPID EMCAL PMD T0 ZDC VZERO");
+ simu.SetMakeDigits ("TRD TOF PHOS HMPID EMCAL PMD T0 ZDC VZERO");
+// simu.SetMakeDigits ("TRD TOF PHOS HMPID EMCAL MUON FMD PMD T0 ZDC VZERO");
simu.SetMakeDigitsFromHits("ITS TPC");
simu.SetWriteRawData("ALL","raw.root",kTRUE);
// simu.SetDefaultStorage("alien://Folder=/alice/data/2008/LHC08c/OCDB/");
// AliQA::SetQARefStorage(Form("%s%s/", AliQA::GetQARefDefaultStorage(), kYear)) ;
AliQA::SetQARefStorage("local://$ALICE_ROOT") ;
// AliQA::SetQARefDataDirName(AliQA::kMONTECARLO) ; //RUN_TYPE
-
+ for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
+ simu.SetQACycles(det, 2) ;
+ }
+
TStopwatch timer;
timer.Start();
simu.Run(nev);
\r
// Set the CDB storage location\r
AliCDBManager * man = AliCDBManager::Instance();\r
- // man->SetDefaultStorage("local://$ALICE_ROOT");\r
- man->SetDefaultStorage("alien://folder=/alice/data/2008/LHC08b/OCDB/");\r
+ man->SetDefaultStorage("local://$ALICE_ROOT");\r
+ //man->SetDefaultStorage("alien://folder=/alice/data/2008/LHC08a/OCDB/");\r
man->SetSpecificStorage("ITS/Calib/*","local://$ALICE_ROOT");\r
\r
// Example in case a specific CDB storage is needed\r
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff