[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 <TFileMerger.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 "AliRawReaderDate.h"
#include "AliRawReaderFile.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 * input )
{
	// Initialize the event source and QA data makers
	
	if (taskIndex == AliQA::kRAWS) {
		TString fileName(input);
		if (fileName.EndsWith("/")) {
			fRawReader = new AliRawReaderFile(fileName);
		} else if (fileName.EndsWith(".root")) {
			fRawReader = new AliRawReaderRoot(fileName);
		} else if (!fileName.IsNull()) {
			fRawReader = new AliRawReaderDate(fileName);
			fRawReader->SelectEvents(7);
		}
	    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("Run Loader not found") ; 
			return kFALSE ; 
		} else {
			if (fRunLoader->GetAliRun()) 
				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 ; 
}

//_____________________________________________________________________________
Bool_t AliQADataMakerSteer::Merge() 
{
	// Merge all the cycles from all detectors in one single file per run
	
	gROOT->ProcessLine(".! ls *QA*.*.*.root > tempo.txt") ; 
	ifstream in("tempo.txt") ; 
	const Int_t runMax = 10 ;  
	TString file[AliQA::kNDET*runMax] ;
	Int_t run[AliQA::kNDET*runMax] ;
	
	Int_t index = 0 ; 
	while ( 1 ) {
		in >> file[index++] ; 
		if ( !in.good() ) 
			break ; 
	}
	Int_t previousRun = -1 ;
	Int_t runIndex = 0 ;  
	for (Int_t ifile = 0 ; ifile < index-1 ; ifile++) {
		TString tmp(file[ifile]) ; 
		tmp.ReplaceAll(".root", "") ; 
		TString det = tmp(0, tmp.Index(".")) ; 
		tmp.Remove(0, tmp.Index(".QA.")+4) ; 
		TString ttmp = tmp(0, tmp.Index(".")) ; 
		Int_t newRun = ttmp.Atoi() ;
		if (newRun != previousRun) {
			run[runIndex] = newRun ; 
			previousRun = newRun ; 
			runIndex++ ; 
		}
		ttmp = tmp(tmp.Index("."), tmp.Length()) ; 
		Int_t cycle = ttmp.Atoi() ;  
		AliInfo(Form("%s : det = %s run = %d cycle = %d \n", file[ifile].Data(), det.Data(), newRun, cycle)) ; 
	}
	for (Int_t irun = 0 ; irun < runIndex ; irun++) {
		TFileMerger merger ; 
		char outFileName[runMax] ; 
		sprintf(outFileName, "Merged.QA.%d.root", runIndex-1) ; 
		merger.OutputFile(outFileName) ; 
		for (Int_t ifile = 0 ; ifile < index-1 ; ifile++) {
			char pattern[100] ; 
			sprintf(pattern, "QA.%d.", runIndex-1) ; 
			TString tmp(file[ifile]) ; 
			if (tmp.Contains(pattern))
				merger.AddFile(tmp) ; 
		}
		merger.Merge() ; 
	}
	
	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 ;
		}
	}

	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
		AliDebug(1, 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 = NULL ; 
		if (fRunLoader) // check if RunLoader exists 
			if ( fRunLoader->GetAliRun() ) // check if AliRun exists in gAlice.root
				detArray = fRunLoader->GetAliRun()->Detectors() ;
		for (UInt_t iDet = 0 ; iDet < fgkNDetectors ; iDet++) {
			if (detArray) {
				AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQA::GetDetName(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>
567d83d9	19	#include <TFileMerger.h>
312e6f8d	20	#include <TPluginManager.h>
	21	#include <TROOT.h>
	22	#include <TString.h>
	23	#include <TSystem.h>
	24
	25	#include "AliESDEvent.h"
	26	#include "AliLog.h"
007fcebb	27	#include "AliModule.h"
312e6f8d	28	#include "AliQA.h"
	29	#include "AliQADataMaker.h"
	30	#include "AliQADataMakerSteer.h"
4ecde5fc	31	#include "AliRawReaderDate.h"
4ecde5fc	32	#include "AliRawReaderFile.h"
312e6f8d	33	#include "AliRawReaderRoot.h"
	34	#include "AliRun.h"
	35	#include "AliRunLoader.h"
	36
	37	ClassImp(AliQADataMakerSteer)
	38
	39	//_____________________________________________________________________________
	40	AliQADataMakerSteer::AliQADataMakerSteer(const char* gAliceFilename, const char * name, const char * title) :
	41	TNamed(name, title),
c65c502a	42	fCycleSame(kFALSE),
312e6f8d	43	fESD(NULL),
	44	fESDTree(NULL),
	45	fFirst(kTRUE),
	46	fGAliceFileName(gAliceFilename),
	47	fRunNumber(0),
	48	fNumberOfEvents(0),
	49	fRawReader(NULL),
	50	fRunLoader(NULL)
	51	{
	52	// default ctor
	53	for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
	54	fLoader[iDet] = NULL ;
	55	fQADataMaker[iDet] = NULL ;
	56	fQACycles[iDet] = 999999 ;
	57	}
	58	}
	59
	60	//_____________________________________________________________________________
	61	AliQADataMakerSteer::AliQADataMakerSteer(const AliQADataMakerSteer & qas) :
	62	TNamed(qas),
c65c502a	63	fCycleSame(kFALSE),
312e6f8d	64	fESD(NULL),
	65	fESDTree(NULL),
	66	fFirst(qas.fFirst),
	67	fGAliceFileName(qas.fGAliceFileName),
	68	fRunNumber(qas.fRunNumber),
	69	fNumberOfEvents(qas.fNumberOfEvents),
	70	fRawReader(NULL),
	71	fRunLoader(NULL)
	72	{
	73	// cpy ctor
	74	for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
	75	fLoader[iDet] = qas.fLoader[iDet] ;
	76	fQADataMaker[iDet] = qas.fQADataMaker[iDet] ;
	77	fQACycles[iDet] = qas.fQACycles[iDet] ;
	78	}
	79	}
	80
	81	//_____________________________________________________________________________
	82	AliQADataMakerSteer & AliQADataMakerSteer::operator = (const AliQADataMakerSteer & qas)
	83	{
	84	// assignment operator
	85	this->~AliQADataMakerSteer() ;
	86	new(this) AliQADataMakerSteer(qas) ;
	87	return *this ;
	88	}
	89
	90	//_____________________________________________________________________________
	91	AliQADataMakerSteer::~AliQADataMakerSteer()
	92	{
	93	// dtor
	94	for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
	95	fLoader[iDet] = NULL;
c65c502a	96	if (fQADataMaker[iDet]) {
	97	(fQADataMaker[iDet])->Finish() ;
	98	delete fQADataMaker[iDet] ;
	99	fQADataMaker[iDet] = NULL ;
	100	}
312e6f8d	101	}
312e6f8d	102
c65c502a	103	fRunLoader = NULL ;
	104	delete fRawReader ;
	105	fRawReader = NULL ;
312e6f8d	106	}
	107
	108	//_____________________________________________________________________________
	109	AliLoader * AliQADataMakerSteer::GetLoader(Int_t iDet)
	110	{
	111	// get the loader for a detector
	112
	113	TString detName = AliQA::GetDetName(iDet) ;
	114	fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
	115	if (fLoader[iDet])
	116	return fLoader[iDet] ;
	117
	118	// load the QA data maker object
	119	TPluginManager* pluginManager = gROOT->GetPluginManager() ;
	120	TString loaderName = "Ali" + detName + "Loader" ;
	121
	122	AliLoader * loader = NULL ;
	123	// first check if a plugin is defined for the quality assurance data maker
	124	TPluginHandler* pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
	125	// if not, add a plugin for it
	126	if (!pluginHandler) {
	127	AliDebug(1, Form("defining plugin for %s", loaderName.Data())) ;
	128	TString libs = gSystem->GetLibraries() ;
	129	if (libs.Contains("lib" + detName + "base.so") \|\| (gSystem->Load("lib" + detName + "base.so") >= 0)) {
	130	pluginManager->AddHandler("AliQADataMaker", detName, loaderName, detName + "loader", loaderName + "()") ;
	131	} else {
	132	pluginManager->AddHandler("AliLoader", detName, loaderName, detName, loaderName + "()") ;
	133	}
	134	pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
	135	}
	136	if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
	137	loader = (AliLoader *) pluginHandler->ExecPlugin(0) ;
	138	}
	139	if (loader)
	140	fLoader[iDet] = loader ;
	141	return loader ;
	142	}
	143
	144	//_____________________________________________________________________________
	145	AliQADataMaker * AliQADataMakerSteer::GetQADataMaker(Int_t iDet)
	146	{
	147	// get the quality assurance data maker for a detector
	148
	149	if (fQADataMaker[iDet])
	150	return fQADataMaker[iDet] ;
	151
	152	AliQADataMaker * qadm = NULL ;
	153
	154	if (fFirst) {
	155	// load the QA data maker object
	156	TPluginManager* pluginManager = gROOT->GetPluginManager() ;
	157	TString detName = AliQA::GetDetName(iDet) ;
	158	TString qadmName = "Ali" + detName + "QADataMaker" ;
	159
	160	// first check if a plugin is defined for the quality assurance data maker
	161	TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
	162	// if not, add a plugin for it
	163	if (!pluginHandler) {
	164	AliDebug(1, Form("defining plugin for %s", qadmName.Data())) ;
	165	TString libs = gSystem->GetLibraries() ;
	166	if (libs.Contains("lib" + detName + "base.so") \|\| (gSystem->Load("lib" + detName + "base.so") >= 0)) {
	167	pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName + "qadm", qadmName + "()") ;
	168	} else {
	169	pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName, qadmName + "()") ;
170	}
171	pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
172	}
173	if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
174	qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0) ;
175	}
176	if (qadm)
177	fQADataMaker[iDet] = qadm ;
178	}
179	return qadm ;
180	}
181
182	//_____________________________________________________________________________
4ecde5fc	183	Bool_t AliQADataMakerSteer::Init(const AliQA::TASKINDEX taskIndex, const char * input )
312e6f8d	184	{
	185	// Initialize the event source and QA data makers
	186
	187	if (taskIndex == AliQA::kRAWS) {
4ecde5fc	188	TString fileName(input);
	189	if (fileName.EndsWith("/")) {
	190	fRawReader = new AliRawReaderFile(fileName);
	191	} else if (fileName.EndsWith(".root")) {
	192	fRawReader = new AliRawReaderRoot(fileName);
	193	} else if (!fileName.IsNull()) {
	194	fRawReader = new AliRawReaderDate(fileName);
	195	fRawReader->SelectEvents(7);
	196	}
312e6f8d	197	if ( ! fRawReader )
	198	return kFALSE ;
	199	fRawReader->NextEvent() ;
	200	fRunNumber = fRawReader->GetRunNumber() ;
	201	fRawReader->RewindEvents();
	202	fNumberOfEvents = 999999 ;
ad265f3e	203	} else if (taskIndex == AliQA::kESDS) {
	204	if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
	205	TFile * esdFile = TFile::Open("AliESDs.root") ;
	206	fESDTree = dynamic_cast<TTree *> (esdFile->Get("esdTree")) ;
	207	fESD = new AliESDEvent() ;
	208	fESD->ReadFromTree(fESDTree) ;
	209	fESDTree->GetEntry(0) ;
	210	fRunNumber = fESD->GetRunNumber() ;
	211	fNumberOfEvents = fESDTree->GetEntries() ;
	212	} else {
	213	AliError("AliESDs.root not found") ;
	214	return kFALSE ;
	215	}
312e6f8d	216	} else {
312e6f8d	217	if ( !InitRunLoader() ) {
808b7099	218	AliError("Run Loader not found") ;
312e6f8d	219	return kFALSE ;
312e6f8d	220	} else {
ad265f3e	221	if (fRunLoader->GetAliRun())
ad265f3e	222	fRunNumber = fRunLoader->GetAliRun()->GetRunNumber() ;
312e6f8d	223	fNumberOfEvents = fRunLoader->GetNumberOfEvents() ;
312e6f8d	224	}
ad265f3e	225	}
ad265f3e	226
312e6f8d	227	// Initialize all QA data makers for all detectors
	228	for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
	229	AliQADataMaker * qadm = GetQADataMaker(iDet) ;
	230	if (!qadm) {
	231	AliWarning(Form("AliQADataMaker not found for %s", AliQA::GetDetName(iDet))) ;
	232	} else {
	233	AliInfo(Form("Data Maker found for %s", qadm->GetName())) ;
	234	qadm->Init(taskIndex, fRunNumber, GetQACycles(iDet)) ;
c65c502a	235	qadm->StartOfCycle(taskIndex, fCycleSame) ;
312e6f8d	236	}
	237	}
	238	fFirst = kFALSE ;
	239	return kTRUE ;
	240	}
	241
	242	//_____________________________________________________________________________
	243	Bool_t AliQADataMakerSteer::InitRunLoader()
	244	{
	245	// get or create the run loader
	246	if (fRunLoader) {
c65c502a	247	fCycleSame = kTRUE ;
312e6f8d	248	return kTRUE ;
	249	}
	250
	251	if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
	252	// load all base libraries to get the loader classes
	253	TString libs = gSystem->GetLibraries() ;
	254	for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
	255	TString detName = AliQA::GetDetName(iDet) ;
	256	if (detName == "HLT")
	257	continue;
	258	if (libs.Contains("lib" + detName + "base.so"))
	259	continue;
	260	gSystem->Load("lib" + detName + "base.so");
	261	}
	262	fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
	263	if (!fRunLoader) {
	264	AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
	265	return kFALSE;
	266	}
	267	fRunLoader->CdGAFile();
	268	if (fRunLoader->LoadgAlice() == 0) {
	269	gAlice = fRunLoader->GetAliRun();
	270	}
	271	if (!gAlice) {
	272	AliError(Form("no gAlice object found in file %s", fGAliceFileName.Data()));
	273	return kFALSE;
	274	}
	275
	276	} else { // galice.root does not exist
	277	AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
	278	return kFALSE;
	279	}
	280
	281	return kTRUE;
	282	}
	283
	284	//_____________________________________________________________________________
	285	Bool_t AliQADataMakerSteer::Finish(const AliQA::TASKINDEX taskIndex)
	286	{
	287	// write output to file for all detectors
	288	for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
	289	AliQADataMaker * qadm = GetQADataMaker(iDet) ;
	290	if (qadm) {
	291	qadm->EndOfCycle(taskIndex) ;
312e6f8d	292	}
	293	}
	294	return kTRUE ;
	295	}
	296
315bba70	297	//_____________________________________________________________________________
	298	Bool_t AliQADataMakerSteer::Merge()
	299	{
567d83d9	300	// Merge all the cycles from all detectors in one single file per run
	301
	302	gROOT->ProcessLine(".! ls QA...root > tempo.txt") ;
	303	ifstream in("tempo.txt") ;
	304	const Int_t runMax = 10 ;
	305	TString file[AliQA::kNDET*runMax] ;
	306	Int_t run[AliQA::kNDET*runMax] ;
	307
	308	Int_t index = 0 ;
	309	while ( 1 ) {
	310	in >> file[index++] ;
	311	if ( !in.good() )
	312	break ;
	313	}
	314	Int_t previousRun = -1 ;
	315	Int_t runIndex = 0 ;
	316	for (Int_t ifile = 0 ; ifile < index-1 ; ifile++) {
	317	TString tmp(file[ifile]) ;
	318	tmp.ReplaceAll(".root", "") ;
	319	TString det = tmp(0, tmp.Index(".")) ;
	320	tmp.Remove(0, tmp.Index(".QA.")+4) ;
	321	TString ttmp = tmp(0, tmp.Index(".")) ;
	322	Int_t newRun = ttmp.Atoi() ;
	323	if (newRun != previousRun) {
	324	run[runIndex] = newRun ;
	325	previousRun = newRun ;
	326	runIndex++ ;
	327	}
	328	ttmp = tmp(tmp.Index("."), tmp.Length()) ;
	329	Int_t cycle = ttmp.Atoi() ;
	330	AliInfo(Form("%s : det = %s run = %d cycle = %d \n", file[ifile].Data(), det.Data(), newRun, cycle)) ;
	331	}
	332	for (Int_t irun = 0 ; irun < runIndex ; irun++) {
	333	TFileMerger merger ;
	334	char outFileName[runMax] ;
	335	sprintf(outFileName, "Merged.QA.%d.root", runIndex-1) ;
	336	merger.OutputFile(outFileName) ;
	337	for (Int_t ifile = 0 ; ifile < index-1 ; ifile++) {
	338	char pattern[100] ;
	339	sprintf(pattern, "QA.%d.", runIndex-1) ;
	340	TString tmp(file[ifile]) ;
	341	if (tmp.Contains(pattern))
	342	merger.AddFile(tmp) ;
	343	}
	344	merger.Merge() ;
	345	}
	346
	347	return kTRUE ;
315bba70	348	}
315bba70	349
c65c502a	350	//_____________________________________________________________________________
	351	void AliQADataMakerSteer::Reset()
	352	{
	353	// Reset the default data members
	354	for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
	355	fLoader[iDet] = NULL;
	356	if (fQADataMaker[iDet]) {
	357	(fQADataMaker[iDet])->Reset() ;
	358	// delete fQADataMaker[iDet] ;
	359	// fQADataMaker[iDet] = NULL ;
	360	}
	361	}
	362
c65c502a	363	delete fRawReader ;
	364	fRawReader = NULL ;
	365
	366	fCycleSame = kFALSE ;
	367	fESD = NULL ;
	368	fESDTree = NULL ;
	369	fFirst = kTRUE ;
	370	fNumberOfEvents = 0 ;
	371	}
	372
312e6f8d	373	//_____________________________________________________________________________
	374	Bool_t AliQADataMakerSteer::Run(const AliQA::TASKINDEX taskIndex, const char * fileName )
	375	{
	376	// Runs all the QA data Maker for every detector
	377	Bool_t rv = kFALSE ;
	378
	379	if ( !Init(taskIndex, fileName) )
	380	return kFALSE ;
	381
	382	// Fill QA data in event loop
	383	for (UInt_t iEvent = 0 ; iEvent < fNumberOfEvents ; iEvent++) {
	384	// Get the event
808b7099	385	AliDebug(1, Form("processing event %d", iEvent));
312e6f8d	386	if ( taskIndex == AliQA::kRAWS ) {
	387	if ( !fRawReader->NextEvent() )
	388	break ;
	389	} else if ( taskIndex == AliQA::kESDS ) {
	390	fESDTree->GetEntry(iEvent) ;
	391	} else {
	392	fRunLoader->GetEvent(iEvent);
	393	}
	394	// loop over detectors
efc25b83	395	TObjArray* detArray = NULL ;
	396	if (fRunLoader) // check if RunLoader exists
	397	if ( fRunLoader->GetAliRun() ) // check if AliRun exists in gAlice.root
	398	detArray = fRunLoader->GetAliRun()->Detectors() ;
312e6f8d	399	for (UInt_t iDet = 0 ; iDet < fgkNDetectors ; iDet++) {
efc25b83	400	if (detArray) {
	401	AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQA::GetDetName(iDet))) ;
	402	if (!det \|\| !det->IsActive())
	403	continue;
	404	}
312e6f8d	405	AliQADataMaker * qadm = GetQADataMaker(iDet) ;
	406	if (!qadm) {
	407	rv = kFALSE ;
	408	} else {
	409	if ( qadm->IsCycleDone() ) {
	410	qadm->EndOfCycle(AliQA::kRAWS) ;
	411	qadm->StartOfCycle(AliQA::kRAWS) ;
	412	}
	413	TTree * data ;
	414	switch (taskIndex) {
	415	case AliQA::kRAWS :
	416	qadm->Exec(taskIndex, fRawReader) ;
	417	break ;
	418	case AliQA::kHITS :
	419	GetLoader(iDet)->LoadHits() ;
	420	data = GetLoader(iDet)->TreeH() ;
	421	if ( ! data ) {
	422	AliWarning(Form(" Hit Tree not found for %s", AliQA::GetDetName(iDet))) ;
	423	} else {
	424	qadm->Exec(taskIndex, data) ;
	425	}
	426	break ;
	427	case AliQA::kSDIGITS :
	428	GetLoader(iDet)->LoadSDigits() ;
	429	data = GetLoader(iDet)->TreeS() ;
	430	if ( ! data ) {
	431	AliWarning(Form(" SDigit Tree not found for %s", AliQA::GetDetName(iDet))) ;
	432	} else {
	433	qadm->Exec(taskIndex, data) ;
	434	}
	435	break;
	436	case AliQA::kDIGITS :
	437	GetLoader(iDet)->LoadDigits() ;
	438	data = GetLoader(iDet)->TreeD() ;
	439	if ( ! data ) {
	440	AliWarning(Form(" Digit Tree not found for %s", AliQA::GetDetName(iDet))) ;
	441	} else {
	442	qadm->Exec(taskIndex, data) ;
	443	}
	444	break;
	445	case AliQA::kRECPOINTS :
	446	GetLoader(iDet)->LoadRecPoints() ;
	447	data = GetLoader(iDet)->TreeR() ;
	448	if (!data) {
	449	AliWarning(Form("RecPoints not found for %s", AliQA::GetDetName(iDet))) ;
	450	} else {
	451	qadm->Exec(taskIndex, data) ;
	452	}
	453	break;
	454	case AliQA::kTRACKSEGMENTS :
	455	break;
	456	case AliQA::kRECPARTICLES :
	457	break;
	458	case AliQA::kESDS :
	459	qadm->Exec(taskIndex, fESD) ;
	460	break;
	461	} //task switch
	462	qadm->Increment() ;
	463	} //data maker exist
	464	} // detector loop
	465	} // event loop
	466	// Save QA data for all detectors
	467	rv = Finish(taskIndex) ;
	468	return rv ;
14e1eccc	469	}