[u/mrichter/AliRoot.git] / STEER / AliQADataMakerSteer.cxx

/**************************************************************************
 * 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$ */

#include <TFile.h>
#include <TPluginManager.h>
#include <TROOT.h>
#include <TString.h>
#include <TSystem.h>

#include "AliESDEvent.h"
#include "AliLog.h"
#include "AliModule.h"
#include "AliQA.h"
#include "AliQADataMaker.h"
#include "AliQADataMakerSteer.h" 
#include "AliRawReaderRoot.h"
#include "AliRun.h"
#include "AliRunLoader.h"

ClassImp(AliQADataMakerSteer) 

//_____________________________________________________________________________
AliQADataMakerSteer::AliQADataMakerSteer(const char* gAliceFilename, const char * name, const char * title) :
	TNamed(name, title), 
	fCycleSame(kFALSE),
	fESD(NULL), 
	fESDTree(NULL),
	fFirst(kTRUE),  
	fGAliceFileName(gAliceFilename), 
	fRunNumber(0), 
	fNumberOfEvents(0), 
	fRawReader(NULL), 
	fRunLoader(NULL)  
{
	// default ctor
	for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
		fLoader[iDet]      = NULL ;
		fQADataMaker[iDet] = NULL ;
		fQACycles[iDet]    = 999999 ;	
	}	
}

//_____________________________________________________________________________
AliQADataMakerSteer::AliQADataMakerSteer(const AliQADataMakerSteer & qas) : 
	TNamed(qas), 
	fCycleSame(kFALSE),
	fESD(NULL), 
	fESDTree(NULL), 
	fFirst(qas.fFirst),  
	fGAliceFileName(qas.fGAliceFileName), 
	fRunNumber(qas.fRunNumber), 
	fNumberOfEvents(qas.fNumberOfEvents), 
	fRawReader(NULL), 
	fRunLoader(NULL)  
{
	// cpy ctor
	for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
		fLoader[iDet]      = qas.fLoader[iDet] ;
		fQADataMaker[iDet] = qas.fQADataMaker[iDet] ;
		fQACycles[iDet]    = qas.fQACycles[iDet] ;	
	}
}

//_____________________________________________________________________________
AliQADataMakerSteer & AliQADataMakerSteer::operator = (const AliQADataMakerSteer & qas) 
{
	// assignment operator
  this->~AliQADataMakerSteer() ;
  new(this) AliQADataMakerSteer(qas) ;
  return *this ;
}

//_____________________________________________________________________________
AliQADataMakerSteer::~AliQADataMakerSteer() 
{
	// dtor
  for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
    fLoader[iDet] = NULL;
	if (fQADataMaker[iDet]) {
		(fQADataMaker[iDet])->Finish() ; 
		delete fQADataMaker[iDet] ;
		fQADataMaker[iDet] = NULL ;
	}
  }

  fRunLoader = NULL ;
  delete fRawReader ;
  fRawReader = NULL ;
}

//_____________________________________________________________________________
AliLoader * AliQADataMakerSteer::GetLoader(Int_t iDet)
{
	// get the loader for a detector
	
	TString detName = AliQA::GetDetName(iDet) ;
    fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
	if (fLoader[iDet]) 
		return fLoader[iDet] ;
	
	// load the QA data maker object
	TPluginManager* pluginManager = gROOT->GetPluginManager() ;
	TString loaderName = "Ali" + detName + "Loader" ;

	AliLoader * loader = NULL ;
	// first check if a plugin is defined for the quality assurance data maker
	TPluginHandler* pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
	// if not, add a plugin for it
	if (!pluginHandler) {
		AliDebug(1, Form("defining plugin for %s", loaderName.Data())) ;
		TString libs = gSystem->GetLibraries() ;
		if (libs.Contains("lib" + detName + "base.so") || (gSystem->Load("lib" + detName + "base.so") >= 0)) {
			pluginManager->AddHandler("AliQADataMaker", detName, loaderName, detName + "loader", loaderName + "()") ;
		} else {
			pluginManager->AddHandler("AliLoader", detName, loaderName, detName, loaderName + "()") ;
		}
		pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
	}
	if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
		loader = (AliLoader *) pluginHandler->ExecPlugin(0) ;
	}
	if (loader) 
		fLoader[iDet] = loader ;
	return loader ;
}

//_____________________________________________________________________________
AliQADataMaker * AliQADataMakerSteer::GetQADataMaker(Int_t iDet)
{
	// get the quality assurance data maker for a detector
	
	if (fQADataMaker[iDet]) 
		return fQADataMaker[iDet] ;
	
	AliQADataMaker * qadm = NULL ;
	
	if (fFirst) {
		// load the QA data maker object
		TPluginManager* pluginManager = gROOT->GetPluginManager() ;
		TString detName = AliQA::GetDetName(iDet) ;
		TString qadmName = "Ali" + detName + "QADataMaker" ;

		// first check if a plugin is defined for the quality assurance data maker
		TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
		// if not, add a plugin for it
		if (!pluginHandler) {
			AliDebug(1, Form("defining plugin for %s", qadmName.Data())) ;
			TString libs = gSystem->GetLibraries() ;
			if (libs.Contains("lib" + detName + "base.so") || (gSystem->Load("lib" + detName + "base.so") >= 0)) {
				pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName + "qadm", qadmName + "()") ;
			} else {
				pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName, qadmName + "()") ;
			}
			pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
		}
		if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
			qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0) ;
		}
		if (qadm) 
			fQADataMaker[iDet] = qadm ;
	}
	return qadm ;
}

//_____________________________________________________________________________
Bool_t AliQADataMakerSteer::Init(const AliQA::TASKINDEX taskIndex, const  char * fileName )
{
	// Initialize the event source and QA data makers
	
	if (taskIndex == AliQA::kRAWS) {
		fRawReader = new AliRawReaderRoot(fileName) ; 
	    if ( ! fRawReader ) 
			return kFALSE ; 
		fRawReader->NextEvent() ; 
		fRunNumber = fRawReader->GetRunNumber() ; 
		fRawReader->RewindEvents();
		fNumberOfEvents = 999999 ;
		
	} else if (taskIndex == AliQA::kESDS) {
		if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
			TFile * esdFile = TFile::Open("AliESDs.root") ;
			fESDTree = dynamic_cast<TTree *> (esdFile->Get("esdTree")) ; 
	        fESD     = new AliESDEvent() ;
            fESD->ReadFromTree(fESDTree) ;
			fESDTree->GetEntry(0) ; 
			fRunNumber = fESD->GetRunNumber() ; 
			fNumberOfEvents = fESDTree->GetEntries() ;
		} else {
			AliError("AliESDs.root not found") ; 
			return kFALSE ; 
		}
		
	} else {
		if ( !InitRunLoader() ) {
			AliError("Problems in getting the Run Loader") ; 
			return kFALSE ; 
		} else {
			fRunNumber      = fRunLoader->GetAliRun()->GetRunNumber() ; 
			fNumberOfEvents = fRunLoader->GetNumberOfEvents() ;
		}
	}
		
	// Initialize all QA data makers for all detectors
	for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
		AliQADataMaker * qadm = GetQADataMaker(iDet) ;
		if (!qadm) {
			AliWarning(Form("AliQADataMaker not found for %s", AliQA::GetDetName(iDet))) ; 
		} else {
			AliInfo(Form("Data Maker found for %s", qadm->GetName())) ; 
			qadm->Init(taskIndex, fRunNumber, GetQACycles(iDet)) ;
			qadm->StartOfCycle(taskIndex, fCycleSame) ;
		}
	} 
	fFirst = kFALSE ;
	return kTRUE ; 
}

//_____________________________________________________________________________
Bool_t AliQADataMakerSteer::InitRunLoader()
{
	// get or create the run loader
	if (fRunLoader) {
		fCycleSame = kTRUE ; 
		return kTRUE ;
	} 
		
	if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
    // load all base libraries to get the loader classes
		TString libs = gSystem->GetLibraries() ;
		for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
			TString detName = AliQA::GetDetName(iDet) ;
			if (detName == "HLT") 
				continue;
			if (libs.Contains("lib" + detName + "base.so")) 
				continue;
			gSystem->Load("lib" + detName + "base.so");
		}
		fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
		if (!fRunLoader) {
			AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
			return kFALSE;
		}
		fRunLoader->CdGAFile();
		if (fRunLoader->LoadgAlice() == 0) {
			gAlice = fRunLoader->GetAliRun();
		}
		if (!gAlice) {
			AliError(Form("no gAlice object found in file %s", fGAliceFileName.Data()));
			return kFALSE;
		}

	} else {               // galice.root does not exist
		AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
		return kFALSE;
    }

  return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliQADataMakerSteer::Finish(const AliQA::TASKINDEX taskIndex) 
{
	// write output to file for all detectors
	for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
		AliQADataMaker * qadm = GetQADataMaker(iDet) ;
		if (qadm) {
			qadm->EndOfCycle(taskIndex) ; 
		}
	}
	return kTRUE ; 
}

//_____________________________________________________________________________
void AliQADataMakerSteer::Reset()
{
	// Reset the default data members
	for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
		fLoader[iDet] = NULL;
		if (fQADataMaker[iDet]) {
			(fQADataMaker[iDet])->Reset() ; 
//			delete fQADataMaker[iDet] ;
//			fQADataMaker[iDet] = NULL ;
		}
	}

	fRunLoader      = NULL ;
	delete fRawReader ;
	fRawReader      = NULL ;

	fCycleSame      = kFALSE ; 
	fESD            = NULL ; 
	fESDTree        = NULL ; 
	fFirst          = kTRUE ;   
	fNumberOfEvents = 0 ;  
}

//_____________________________________________________________________________
Bool_t AliQADataMakerSteer::Run(const AliQA::TASKINDEX taskIndex, const  char * fileName )
{
	// Runs all the QA data Maker for every detector
	Bool_t rv = kFALSE ;
	
	if ( !Init(taskIndex, fileName) ) 
		return kFALSE ; 
		
    // Fill QA data in event loop 
	for (UInt_t iEvent = 0 ; iEvent < fNumberOfEvents ; iEvent++) {
		// Get the event
		AliInfo(Form("processing event %d", iEvent));
		if ( taskIndex == AliQA::kRAWS ) {
			if ( !fRawReader->NextEvent() )
				break ;
		} else if ( taskIndex == AliQA::kESDS ) {
			fESDTree->GetEntry(iEvent) ;
		} else {
			fRunLoader->GetEvent(iEvent);
		}
		// loop over detectors
		TObjArray* detArray = fRunLoader->GetAliRun()->Detectors() ;
		for (UInt_t iDet = 0 ; iDet < fgkNDetectors ; iDet++) {
			AliModule* det = static_cast<AliModule*>(detArray->At(iDet)) ;
			if (!det || !det->IsActive()) 
				continue;
			AliQADataMaker * qadm = GetQADataMaker(iDet) ;
			if (!qadm) {
				rv = kFALSE ;
			} else {
				if ( qadm->IsCycleDone() ) {
					qadm->EndOfCycle(AliQA::kRAWS) ;
					qadm->StartOfCycle(AliQA::kRAWS) ;
				}
				TTree * data ; 
				switch (taskIndex) {
					case AliQA::kRAWS :
						qadm->Exec(taskIndex, fRawReader) ; 
					break ; 
					case AliQA::kHITS :
						GetLoader(iDet)->LoadHits() ; 
						data = GetLoader(iDet)->TreeH() ; 
						if ( ! data ) {
							AliWarning(Form(" Hit Tree not found for  %s", AliQA::GetDetName(iDet))) ; 
						} else {
							qadm->Exec(taskIndex, data) ;
						} 
					break ;
					case AliQA::kSDIGITS :
						GetLoader(iDet)->LoadSDigits() ; 
						data = GetLoader(iDet)->TreeS() ; 
						if ( ! data ) {
							AliWarning(Form(" SDigit Tree not found for  %s", AliQA::GetDetName(iDet))) ; 
						} else {
							qadm->Exec(taskIndex, data) ; 
						}
					break; 
					case AliQA::kDIGITS :
						GetLoader(iDet)->LoadDigits() ; 
						data = GetLoader(iDet)->TreeD() ; 
						if ( ! data ) {
							AliWarning(Form(" Digit Tree not found for  %s", AliQA::GetDetName(iDet))) ; 
						} else {
							qadm->Exec(taskIndex, data) ;
						}
					break; 
					case AliQA::kRECPOINTS :
						GetLoader(iDet)->LoadRecPoints() ; 
						data = GetLoader(iDet)->TreeR() ; 
						if (!data) {
							AliWarning(Form("RecPoints not found for %s", AliQA::GetDetName(iDet))) ; 
						} else {
							qadm->Exec(taskIndex, data) ; 
						}
					break; 
					case AliQA::kTRACKSEGMENTS :
					break; 
					case AliQA::kRECPARTICLES :
					break; 
					case AliQA::kESDS :
						qadm->Exec(taskIndex, fESD) ;
					break; 
				} //task switch
				qadm->Increment() ; 
			} //data maker exist
		} // detector loop
	} // event loop	
	// Save QA data for all detectors
	rv = Finish(taskIndex) ;
	return rv ; 
}
Commit	Line	Data
312e6f8d	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17
	18	#include <TFile.h>
	19	#include <TPluginManager.h>
	20	#include <TROOT.h>
	21	#include <TString.h>
	22	#include <TSystem.h>
	23
	24	#include "AliESDEvent.h"
	25	#include "AliLog.h"
007fcebb	26	#include "AliModule.h"
312e6f8d	27	#include "AliQA.h"
	28	#include "AliQADataMaker.h"
	29	#include "AliQADataMakerSteer.h"
	30	#include "AliRawReaderRoot.h"
	31	#include "AliRun.h"
	32	#include "AliRunLoader.h"
	33
	34	ClassImp(AliQADataMakerSteer)
	35
	36	//_____________________________________________________________________________
	37	AliQADataMakerSteer::AliQADataMakerSteer(const char* gAliceFilename, const char * name, const char * title) :
	38	TNamed(name, title),
c65c502a	39	fCycleSame(kFALSE),
312e6f8d	40	fESD(NULL),
	41	fESDTree(NULL),
	42	fFirst(kTRUE),
	43	fGAliceFileName(gAliceFilename),
	44	fRunNumber(0),
	45	fNumberOfEvents(0),
	46	fRawReader(NULL),
	47	fRunLoader(NULL)
	48	{
	49	// default ctor
	50	for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
	51	fLoader[iDet] = NULL ;
	52	fQADataMaker[iDet] = NULL ;
	53	fQACycles[iDet] = 999999 ;
	54	}
	55	}
	56
	57	//_____________________________________________________________________________
	58	AliQADataMakerSteer::AliQADataMakerSteer(const AliQADataMakerSteer & qas) :
	59	TNamed(qas),
c65c502a	60	fCycleSame(kFALSE),
312e6f8d	61	fESD(NULL),
	62	fESDTree(NULL),
	63	fFirst(qas.fFirst),
	64	fGAliceFileName(qas.fGAliceFileName),
	65	fRunNumber(qas.fRunNumber),
	66	fNumberOfEvents(qas.fNumberOfEvents),
	67	fRawReader(NULL),
	68	fRunLoader(NULL)
	69	{
	70	// cpy ctor
	71	for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
	72	fLoader[iDet] = qas.fLoader[iDet] ;
	73	fQADataMaker[iDet] = qas.fQADataMaker[iDet] ;
	74	fQACycles[iDet] = qas.fQACycles[iDet] ;
	75	}
	76	}
	77
	78	//_____________________________________________________________________________
	79	AliQADataMakerSteer & AliQADataMakerSteer::operator = (const AliQADataMakerSteer & qas)
	80	{
	81	// assignment operator
	82	this->~AliQADataMakerSteer() ;
	83	new(this) AliQADataMakerSteer(qas) ;
	84	return *this ;
	85	}
	86
	87	//_____________________________________________________________________________
	88	AliQADataMakerSteer::~AliQADataMakerSteer()
	89	{
	90	// dtor
	91	for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
	92	fLoader[iDet] = NULL;
c65c502a	93	if (fQADataMaker[iDet]) {
	94	(fQADataMaker[iDet])->Finish() ;
	95	delete fQADataMaker[iDet] ;
	96	fQADataMaker[iDet] = NULL ;
	97	}
312e6f8d	98	}
312e6f8d	99
c65c502a	100	fRunLoader = NULL ;
	101	delete fRawReader ;
	102	fRawReader = NULL ;
312e6f8d	103	}
	104
	105	//_____________________________________________________________________________
	106	AliLoader * AliQADataMakerSteer::GetLoader(Int_t iDet)
	107	{
	108	// get the loader for a detector
	109
	110	TString detName = AliQA::GetDetName(iDet) ;
	111	fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
	112	if (fLoader[iDet])
	113	return fLoader[iDet] ;
	114
	115	// load the QA data maker object
	116	TPluginManager* pluginManager = gROOT->GetPluginManager() ;
	117	TString loaderName = "Ali" + detName + "Loader" ;
	118
	119	AliLoader * loader = NULL ;
	120	// first check if a plugin is defined for the quality assurance data maker
	121	TPluginHandler* pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
	122	// if not, add a plugin for it
	123	if (!pluginHandler) {
	124	AliDebug(1, Form("defining plugin for %s", loaderName.Data())) ;
	125	TString libs = gSystem->GetLibraries() ;
	126	if (libs.Contains("lib" + detName + "base.so") \|\| (gSystem->Load("lib" + detName + "base.so") >= 0)) {
	127	pluginManager->AddHandler("AliQADataMaker", detName, loaderName, detName + "loader", loaderName + "()") ;
	128	} else {
	129	pluginManager->AddHandler("AliLoader", detName, loaderName, detName, loaderName + "()") ;
	130	}
	131	pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
	132	}
	133	if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
	134	loader = (AliLoader *) pluginHandler->ExecPlugin(0) ;
	135	}
	136	if (loader)
	137	fLoader[iDet] = loader ;
	138	return loader ;
	139	}
	140
	141	//_____________________________________________________________________________
	142	AliQADataMaker * AliQADataMakerSteer::GetQADataMaker(Int_t iDet)
	143	{
	144	// get the quality assurance data maker for a detector
	145
	146	if (fQADataMaker[iDet])
	147	return fQADataMaker[iDet] ;
	148
	149	AliQADataMaker * qadm = NULL ;
	150
	151	if (fFirst) {
	152	// load the QA data maker object
	153	TPluginManager* pluginManager = gROOT->GetPluginManager() ;
	154	TString detName = AliQA::GetDetName(iDet) ;
	155	TString qadmName = "Ali" + detName + "QADataMaker" ;
	156
	157	// first check if a plugin is defined for the quality assurance data maker
	158	TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
	159	// if not, add a plugin for it
	160	if (!pluginHandler) {
	161	AliDebug(1, Form("defining plugin for %s", qadmName.Data())) ;
	162	TString libs = gSystem->GetLibraries() ;
	163	if (libs.Contains("lib" + detName + "base.so") \|\| (gSystem->Load("lib" + detName + "base.so") >= 0)) {
	164	pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName + "qadm", qadmName + "()") ;
	165	} else {
	166	pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName, qadmName + "()") ;
167	}
168	pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
169	}
170	if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
171	qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0) ;
172	}
173	if (qadm)
174	fQADataMaker[iDet] = qadm ;
175	}
176	return qadm ;
177	}
178
179	//_____________________________________________________________________________
180	Bool_t AliQADataMakerSteer::Init(const AliQA::TASKINDEX taskIndex, const char * fileName )
181	{
182	// Initialize the event source and QA data makers
183
184	if (taskIndex == AliQA::kRAWS) {
185	fRawReader = new AliRawReaderRoot(fileName) ;
186	if ( ! fRawReader )
187	return kFALSE ;
188	fRawReader->NextEvent() ;
189	fRunNumber = fRawReader->GetRunNumber() ;
190	fRawReader->RewindEvents();
191	fNumberOfEvents = 999999 ;
192
193	} else if (taskIndex == AliQA::kESDS) {
194	if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
195	TFile * esdFile = TFile::Open("AliESDs.root") ;
196	fESDTree = dynamic_cast<TTree *> (esdFile->Get("esdTree")) ;
197	fESD = new AliESDEvent() ;
198	fESD->ReadFromTree(fESDTree) ;
199	fESDTree->GetEntry(0) ;
200	fRunNumber = fESD->GetRunNumber() ;
201	fNumberOfEvents = fESDTree->GetEntries() ;
202	} else {
203	AliError("AliESDs.root not found") ;
204	return kFALSE ;
205	}
206
207	} else {
208	if ( !InitRunLoader() ) {
209	AliError("Problems in getting the Run Loader") ;
210	return kFALSE ;
211	} else {
212	fRunNumber = fRunLoader->GetAliRun()->GetRunNumber() ;
213	fNumberOfEvents = fRunLoader->GetNumberOfEvents() ;
214	}
215	}
216
217	// Initialize all QA data makers for all detectors
218	for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
219	AliQADataMaker * qadm = GetQADataMaker(iDet) ;
220	if (!qadm) {
221	AliWarning(Form("AliQADataMaker not found for %s", AliQA::GetDetName(iDet))) ;
222	} else {
223	AliInfo(Form("Data Maker found for %s", qadm->GetName())) ;
224	qadm->Init(taskIndex, fRunNumber, GetQACycles(iDet)) ;
c65c502a	225	qadm->StartOfCycle(taskIndex, fCycleSame) ;
312e6f8d	226	}
	227	}
	228	fFirst = kFALSE ;
	229	return kTRUE ;
	230	}
	231
	232	//_____________________________________________________________________________
	233	Bool_t AliQADataMakerSteer::InitRunLoader()
	234	{
	235	// get or create the run loader
	236	if (fRunLoader) {
c65c502a	237	fCycleSame = kTRUE ;
312e6f8d	238	return kTRUE ;
	239	}
	240
	241	if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
	242	// load all base libraries to get the loader classes
	243	TString libs = gSystem->GetLibraries() ;
	244	for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
	245	TString detName = AliQA::GetDetName(iDet) ;
	246	if (detName == "HLT")
	247	continue;
	248	if (libs.Contains("lib" + detName + "base.so"))
	249	continue;
	250	gSystem->Load("lib" + detName + "base.so");
	251	}
	252	fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
	253	if (!fRunLoader) {
	254	AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
	255	return kFALSE;
	256	}
	257	fRunLoader->CdGAFile();
	258	if (fRunLoader->LoadgAlice() == 0) {
	259	gAlice = fRunLoader->GetAliRun();
	260	}
	261	if (!gAlice) {
	262	AliError(Form("no gAlice object found in file %s", fGAliceFileName.Data()));
	263	return kFALSE;
	264	}
	265
	266	} else { // galice.root does not exist
	267	AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
	268	return kFALSE;
	269	}
	270
	271	return kTRUE;
	272	}
	273
	274	//_____________________________________________________________________________
	275	Bool_t AliQADataMakerSteer::Finish(const AliQA::TASKINDEX taskIndex)
	276	{
	277	// write output to file for all detectors
	278	for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
	279	AliQADataMaker * qadm = GetQADataMaker(iDet) ;
	280	if (qadm) {
	281	qadm->EndOfCycle(taskIndex) ;
312e6f8d	282	}
	283	}
	284	return kTRUE ;
	285	}
	286
c65c502a	287	//_____________________________________________________________________________
	288	void AliQADataMakerSteer::Reset()
	289	{
	290	// Reset the default data members
	291	for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
	292	fLoader[iDet] = NULL;
	293	if (fQADataMaker[iDet]) {
	294	(fQADataMaker[iDet])->Reset() ;
	295	// delete fQADataMaker[iDet] ;
	296	// fQADataMaker[iDet] = NULL ;
	297	}
	298	}
	299
	300	fRunLoader = NULL ;
	301	delete fRawReader ;
	302	fRawReader = NULL ;
	303
	304	fCycleSame = kFALSE ;
	305	fESD = NULL ;
	306	fESDTree = NULL ;
	307	fFirst = kTRUE ;
	308	fNumberOfEvents = 0 ;
	309	}
	310
312e6f8d	311	//_____________________________________________________________________________
	312	Bool_t AliQADataMakerSteer::Run(const AliQA::TASKINDEX taskIndex, const char * fileName )
	313	{
	314	// Runs all the QA data Maker for every detector
	315	Bool_t rv = kFALSE ;
	316
	317	if ( !Init(taskIndex, fileName) )
	318	return kFALSE ;
	319
	320	// Fill QA data in event loop
	321	for (UInt_t iEvent = 0 ; iEvent < fNumberOfEvents ; iEvent++) {
	322	// Get the event
	323	AliInfo(Form("processing event %d", iEvent));
	324	if ( taskIndex == AliQA::kRAWS ) {
	325	if ( !fRawReader->NextEvent() )
	326	break ;
	327	} else if ( taskIndex == AliQA::kESDS ) {
	328	fESDTree->GetEntry(iEvent) ;
	329	} else {
	330	fRunLoader->GetEvent(iEvent);
	331	}
	332	// loop over detectors
007fcebb	333	TObjArray* detArray = fRunLoader->GetAliRun()->Detectors() ;
312e6f8d	334	for (UInt_t iDet = 0 ; iDet < fgkNDetectors ; iDet++) {
007fcebb	335	AliModule* det = static_cast<AliModule*>(detArray->At(iDet)) ;
	336	if (!det \|\| !det->IsActive())
	337	continue;
312e6f8d	338	AliQADataMaker * qadm = GetQADataMaker(iDet) ;
	339	if (!qadm) {
	340	rv = kFALSE ;
	341	} else {
	342	if ( qadm->IsCycleDone() ) {
	343	qadm->EndOfCycle(AliQA::kRAWS) ;
	344	qadm->StartOfCycle(AliQA::kRAWS) ;
	345	}
	346	TTree * data ;
	347	switch (taskIndex) {
	348	case AliQA::kRAWS :
	349	qadm->Exec(taskIndex, fRawReader) ;
	350	break ;
	351	case AliQA::kHITS :
	352	GetLoader(iDet)->LoadHits() ;
	353	data = GetLoader(iDet)->TreeH() ;
	354	if ( ! data ) {
	355	AliWarning(Form(" Hit Tree not found for %s", AliQA::GetDetName(iDet))) ;
	356	} else {
	357	qadm->Exec(taskIndex, data) ;
	358	}
	359	break ;
	360	case AliQA::kSDIGITS :
	361	GetLoader(iDet)->LoadSDigits() ;
	362	data = GetLoader(iDet)->TreeS() ;
	363	if ( ! data ) {
	364	AliWarning(Form(" SDigit Tree not found for %s", AliQA::GetDetName(iDet))) ;
	365	} else {
	366	qadm->Exec(taskIndex, data) ;
	367	}
	368	break;
	369	case AliQA::kDIGITS :
	370	GetLoader(iDet)->LoadDigits() ;
	371	data = GetLoader(iDet)->TreeD() ;
	372	if ( ! data ) {
	373	AliWarning(Form(" Digit Tree not found for %s", AliQA::GetDetName(iDet))) ;
	374	} else {
	375	qadm->Exec(taskIndex, data) ;
	376	}
	377	break;
	378	case AliQA::kRECPOINTS :
	379	GetLoader(iDet)->LoadRecPoints() ;
	380	data = GetLoader(iDet)->TreeR() ;
	381	if (!data) {
	382	AliWarning(Form("RecPoints not found for %s", AliQA::GetDetName(iDet))) ;
	383	} else {
	384	qadm->Exec(taskIndex, data) ;
	385	}
	386	break;
	387	case AliQA::kTRACKSEGMENTS :
	388	break;
	389	case AliQA::kRECPARTICLES :
	390	break;
	391	case AliQA::kESDS :
	392	qadm->Exec(taskIndex, fESD) ;
	393	break;
	394	} //task switch
	395	qadm->Increment() ;
	396	} //data maker exist
	397	} // detector loop
	398	} // event loop
	399	// Save QA data for all detectors
	400	rv = Finish(taskIndex) ;
	401	return rv ;
14e1eccc	402	}