[u/mrichter/AliRoot.git] / STEER / AliQADataMaker.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$ */

//
//  Base Class
//  Produces the data needed to calculate the quality assurance. 
//  All data must be mergeable objects.
//  Y. Schutz CERN July 2007
//

// --- ROOT system ---
#include <TROOT.h> 
#include <TCanvas.h> 
#include <TPaveText.h>
#include <TSystem.h> 
#include <TFile.h>
#include <TList.h> 
#include <TTree.h>
#include <TClonesArray.h>
#include <TParameter.h>
#include <TH1K.h>
#include <TH2C.h>
#include <TH2D.h>
#include <TH2F.h>
#include <TH2I.h>
#include <TH3C.h>
#include <TH3D.h>
#include <TH3F.h>
#include <TH3I.h>
#include <TH3S.h>

// --- Standard library ---

// --- AliRoot header files ---
#include "AliLog.h"
#include "AliQADataMaker.h"
#include "AliQAChecker.h"
#include "AliESDEvent.h"
#include "AliRawReader.h"
#include "AliDetectorRecoParam.h"


ClassImp(AliQADataMaker)
             
//____________________________________________________________________________ 
AliQADataMaker::AliQADataMaker(const Char_t * name, const Char_t * title) : 
  TNamed(name, title), 
  fOutput(0x0),
  fDetectorDir(0x0),
  fDetectorDirName(""), 
  fCurrentCycle(0), 
  fCycle(9999999), 
  fCycleCounter(0), 
  fWriteExpert(kFALSE),
  fParameterList(new TList*[AliRecoParam::kNSpecies]), 
  fRun(0), 
  fEventSpecie(AliRecoParam::kDefault), 
  fImage(new TCanvas*[AliRecoParam::kNSpecies]), 
  fPrintImage(kTRUE) 
{
  // ctor
  fDetectorDirName = GetName() ; 
    for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
      fParameterList[specie] = NULL ; 
      fImage[specie] = NULL ; 
    }
}

//____________________________________________________________________________ 
AliQADataMaker::AliQADataMaker(const AliQADataMaker& qadm) :
  TNamed(qadm.GetName(), qadm.GetTitle()),
  fOutput(qadm.fOutput),
  fDetectorDir(qadm.fDetectorDir),
  fDetectorDirName(qadm.fDetectorDirName),
  fCurrentCycle(qadm.fCurrentCycle), 
  fCycle(qadm.fCycle), 
  fCycleCounter(qadm.fCycleCounter), 
  fWriteExpert(qadm.fWriteExpert),
  fParameterList(qadm.fParameterList),  
  fRun(qadm.fRun), 
  fEventSpecie(qadm.fEventSpecie), 
  fImage(qadm.fImage),  
  fPrintImage(kTRUE)

{
  //copy ctor
  fDetectorDirName = GetName() ; 
  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
    fParameterList[specie] = qadm.fParameterList[specie] ; 
    fImage[specie] = qadm.fImage[specie] ; 
  }
}

//____________________________________________________________________________ 
AliQADataMaker::~AliQADataMaker()
{
  for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
    if ( fImage[esIndex] ) 
      delete fImage[esIndex] ;
    if (fParameterList[esIndex] )
      delete fParameterList[esIndex] ; 
  }
  delete[] fImage ; 
  delete[] fParameterList ; 
}

//____________________________________________________________________________
Int_t AliQADataMaker::Add2List(TH1 * hist, const Int_t index, TObjArray ** list, const Bool_t expert, const Bool_t image, const Bool_t saveForCorr) 
{ 
	// Set histograms memory resident and add to the list
	// Maximm allowed is 10000
  
  Int_t rv = -1 ; 
  TClass * classType = hist->Class() ;
  TString className(classType->GetName()) ; 
  if( ! className.BeginsWith("T") && ! classType->InheritsFrom("TH1") ) {
    AliError(Form("QA data Object must be a generic ROOT object and derive fom TH1 and not %s", className.Data())) ; 
	} else if ( index > 10000 ) {
		AliError("Max number of authorized QA objects is 10000") ; 
  } else {
    hist->SetDirectory(0) ; 
    if (expert) 
      hist->SetBit(AliQAv1::GetExpertBit()) ;
    if (image) 
      hist->SetBit(AliQAv1::GetImageBit()) ;  
    const Char_t * name = Form("%s_%s", AliRecoParam::GetEventSpecieName(fEventSpecie), hist->GetName()) ;
    hist->SetName(name) ; 
    if(saveForCorr) {  
      const Char_t * cname = Form("%s_%s", list[AliRecoParam::AConvert(AliRecoParam::kDefault)]->GetName(), hist->GetName()) ;  
      TParameter<double> * p = new TParameter<double>(cname, 9999.9999) ;
      if ( fParameterList[AliRecoParam::AConvert(fEventSpecie)] == NULL )
        fParameterList[AliRecoParam::AConvert(fEventSpecie)] = new TList() ; 
      fParameterList[AliRecoParam::AConvert(fEventSpecie)]->Add(p) ;
    }
    list[AliRecoParam::AConvert(fEventSpecie)]->AddAtAndExpand(hist, index) ; 
    rv = list[AliRecoParam::AConvert(fEventSpecie)]->GetLast() ;
  }
  return rv ; 
}

//____________________________________________________________________________
TH1 *  AliQADataMaker::CloneMe(TH1 * hist, Int_t specie) const  
{
  // clones a histogram 
  const Char_t * name = Form("%s_%s", AliRecoParam::GetEventSpecieName(specie), hist->GetName()) ;
  TH1 * hClone = static_cast<TH1 *>(hist->Clone(name)) ; 
  if ( hist->TestBit(AliQAv1::GetExpertBit()) )
    hClone->SetBit(AliQAv1::GetExpertBit()) ; 
  if ( hist->TestBit(AliQAv1::GetImageBit()) )
    hClone->SetBit(AliQAv1::GetImageBit()) ; 
  return hClone ; 
}

//____________________________________________________________________________
void AliQADataMaker::DefaultEndOfDetectorCycle(AliQAv1::TASKINDEX_t task) 
{
	// this method must be oveloaded by detectors
	// sets the QA result to Fatal
	AliQAv1::Instance(AliQAv1::GetDetIndex(GetName())) ;
	AliQAv1 * qa = AliQAv1::Instance(task) ;
  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
    qa->Set(AliQAv1::kFATAL, specie) ; 
	AliQAv1::GetQAResultFile()->cd() ; 
	qa->Write(AliQAv1::GetQAName(), kWriteDelete) ;   
	AliQAv1::GetQAResultFile()->Close() ; 
}

//____________________________________________________________________________ 
void AliQADataMaker::Finish() const 
{ 
	// write to the output File
	if (fOutput) 
		fOutput->Close() ; 
} 

//____________________________________________________________________________ 
TObject * AliQADataMaker::GetData(TObjArray ** list, const Int_t index)  
{ 
	// Returns the QA object at index. Limit is 100. 
  if ( ! list ) {
		AliError("Data list is NULL !!") ; 
		return NULL ; 		
	}

  SetEventSpecie(fEventSpecie) ;  
  Int_t esindex = AliRecoParam::AConvert(fEventSpecie) ; 
  TH1 * histClone = NULL ; 
	if (list[esindex]) {
		if ( index > 10000 ) {
			AliError("Max number of authorized QA objects is 10000") ; 
		} else {
      if ( list[esindex]->At(index) )  {
        histClone = static_cast<TH1*>(list[esindex]->At(index)) ; 
      } 	
    }
  }
  return histClone ; 		
}

//____________________________________________________________________________ 
TObjArray*  AliQADataMaker::Init(AliQAv1::TASKINDEX_t task, AliRecoParam::EventSpecie_t es, Int_t cycles)
{
  // Initialializes and  returns the QAData list for a given event specie
  TObjArray ** ar = Init(task, cycles) ; 
  return ar[AliRecoParam::AConvert(es)] ;  
}

//____________________________________________________________________________ 
void AliQADataMaker::MakeTheImage( TObjArray ** list, AliQAv1::TASKINDEX_t task, const Char_t * mode) 
{
  // makes the QA image for sim and rec
  TIter next(list[AliRecoParam::AConvert(fEventSpecie)]) ;  
  TH1 * hdata = NULL ; 
  Int_t nImages = 0 ;
  while ( (hdata=static_cast<TH1 *>(next())) ) {
    TString cln(hdata->ClassName()) ; 
    if ( ! cln.Contains("TH1") )
      continue ; 
    if ( hdata->TestBit(AliQAv1::GetImageBit()) )
      nImages++; 
  }
  if ( nImages == 0 ) {
    AliWarning(Form("No histogram will be plotted for %s %s\n", GetName(), AliQAv1::GetTaskName(task).Data())) ;  
  } else {
    AliDebug(AliQAv1::GetQADebugLevel(), Form("%d histograms will be plotted for %s %s\n", nImages, GetName(), AliQAv1::GetTaskName(task).Data())) ;  
    for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
      if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(esIndex)) ) 
        continue ;
      const Char_t * title = Form("QA_%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(esIndex)) ; 
      if ( !fImage[esIndex] ) {
        fImage[esIndex] = new TCanvas(title, title) ;
      }
      fImage[esIndex]->Clear() ; 
      fImage[esIndex]->SetTitle(title) ; 
      fImage[esIndex]->cd() ; 
      TPaveText someText(0.015, 0.015, 0.98, 0.98) ;
      someText.AddText(title) ;
      someText.Draw() ; 
      fImage[esIndex]->Print(Form("%s%s%d.%s", AliQAv1::GetImageFileName(), mode, fRun, AliQAv1::GetImageFileFormat())) ; 
      fImage[esIndex]->Clear() ; 
      Int_t nx = TMath::Sqrt(nImages) ; 
      Int_t ny = nx  ; 
      if ( nx < TMath::Sqrt(nImages)) 
        ny++ ; 
      fImage[esIndex]->Divide(nx, ny) ; 
      TIter nexthist(list[esIndex]) ; 
      TH1* hist = NULL ;
      Int_t npad = 1 ; 
      fImage[esIndex]->cd(npad) ; 
      while ( (hist=static_cast<TH1*>(nexthist())) ) {
        TString cln(hist->ClassName()) ; 
        if ( ! cln.Contains("TH1") )
          continue ; 
        if(hist->TestBit(AliQAv1::GetImageBit())) {
          hist->Draw() ; 
          fImage[esIndex]->cd(++npad) ; 
        }
      }
      fImage[esIndex]->Print(Form("%s%s%d.%s", AliQAv1::GetImageFileName(), mode, fRun, AliQAv1::GetImageFileFormat())) ; 
    }
  }  
}
Commit	Line	Data
421ab0fb	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
	17	/* $Id$ */
	18
202374b1	19	//
	20	// Base Class
	21	// Produces the data needed to calculate the quality assurance.
	22	// All data must be mergeable objects.
	23	// Y. Schutz CERN July 2007
	24	//
421ab0fb	25
421ab0fb	26	// --- ROOT system ---
eca4fa66	27	#include <TROOT.h>
71f27f1f	28	#include <TCanvas.h>
fec0891b	29	#include <TPaveText.h>
421ab0fb	30	#include <TSystem.h>
421ab0fb	31	#include <TFile.h>
6c18591a	32	#include <TList.h>
d76c31f4	33	#include <TTree.h>
d5cf81bd	34	#include <TClonesArray.h>
a2b64fbd	35	#include <TParameter.h>
57acd2d2	36	#include <TH1K.h>
	37	#include <TH2C.h>
	38	#include <TH2D.h>
	39	#include <TH2F.h>
	40	#include <TH2I.h>
	41	#include <TH3C.h>
	42	#include <TH3D.h>
	43	#include <TH3F.h>
	44	#include <TH3I.h>
	45	#include <TH3S.h>
421ab0fb	46
	47	// --- Standard library ---
	48
	49	// --- AliRoot header files ---
	50	#include "AliLog.h"
2e42b4d4	51	#include "AliQADataMaker.h"
2e42b4d4	52	#include "AliQAChecker.h"
d76c31f4	53	#include "AliESDEvent.h"
d5cf81bd	54	#include "AliRawReader.h"
5e232cd6	55	#include "AliDetectorRecoParam.h"
5e232cd6	56
421ab0fb	57
2e42b4d4	58	ClassImp(AliQADataMaker)
312e6f8d	59
421ab0fb	60	//____________________________________________________________________________
fec0891b	61	AliQADataMaker::AliQADataMaker(const Char_t * name, const Char_t * title) :
421ab0fb	62	TNamed(name, title),
421ab0fb	63	fOutput(0x0),
6c18591a	64	fDetectorDir(0x0),
312e6f8d	65	fDetectorDirName(""),
930e6e3e	66	fCurrentCycle(0),
5b188f2f	67	fCycle(9999999),
5b188f2f	68	fCycleCounter(0),
b1af1125	69	fWriteExpert(kFALSE),
57acd2d2	70	fParameterList(new TList*[AliRecoParam::kNSpecies]),
57acd2d2	71	fRun(0),
71f27f1f	72	fEventSpecie(AliRecoParam::kDefault),
71f27f1f	73	fImage(new TCanvas*[AliRecoParam::kNSpecies]),
fec0891b	74	fPrintImage(kTRUE)
421ab0fb	75	{
421ab0fb	76	// ctor
421ab0fb	77	fDetectorDirName = GetName() ;
71f27f1f	78	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
	79	fParameterList[specie] = NULL ;
	80	fImage[specie] = NULL ;
	81	}
421ab0fb	82	}
	83
	84	//____________________________________________________________________________
2e42b4d4	85	AliQADataMaker::AliQADataMaker(const AliQADataMaker& qadm) :
421ab0fb	86	TNamed(qadm.GetName(), qadm.GetTitle()),
421ab0fb	87	fOutput(qadm.fOutput),
6c18591a	88	fDetectorDir(qadm.fDetectorDir),
312e6f8d	89	fDetectorDirName(qadm.fDetectorDirName),
5b188f2f	90	fCurrentCycle(qadm.fCurrentCycle),
	91	fCycle(qadm.fCycle),
	92	fCycleCounter(qadm.fCycleCounter),
b1af1125	93	fWriteExpert(qadm.fWriteExpert),
a2b64fbd	94	fParameterList(qadm.fParameterList),
57acd2d2	95	fRun(qadm.fRun),
71f27f1f	96	fEventSpecie(qadm.fEventSpecie),
71f27f1f	97	fImage(qadm.fImage),
fec0891b	98	fPrintImage(kTRUE)
71f27f1f	99
421ab0fb	100	{
	101	//copy ctor
	102	fDetectorDirName = GetName() ;
eca4fa66	103	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
	104	fParameterList[specie] = qadm.fParameterList[specie] ;
	105	fImage[specie] = qadm.fImage[specie] ;
	106	}
421ab0fb	107	}
421ab0fb	108
71f27f1f	109	//____________________________________________________________________________
	110	AliQADataMaker::~AliQADataMaker()
	111	{
	112	for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
	113	if ( fImage[esIndex] )
	114	delete fImage[esIndex] ;
	115	if (fParameterList[esIndex] )
	116	delete fParameterList[esIndex] ;
	117	}
	118	delete[] fImage ;
	119	delete[] fParameterList ;
	120	}
	121
ba7aca7d	122	//____________________________________________________________________________
7d297381	123	Int_t AliQADataMaker::Add2List(TH1 * hist, const Int_t index, TObjArray ** list, const Bool_t expert, const Bool_t image, const Bool_t saveForCorr)
ba7aca7d	124	{
04236e67	125	// Set histograms memory resident and add to the list
ab4351aa	126	// Maximm allowed is 10000
57acd2d2	127
	128	Int_t rv = -1 ;
	129	TClass * classType = hist->Class() ;
	130	TString className(classType->GetName()) ;
	131	if( ! className.BeginsWith("T") && ! classType->InheritsFrom("TH1") ) {
	132	AliError(Form("QA data Object must be a generic ROOT object and derive fom TH1 and not %s", className.Data())) ;
	133	} else if ( index > 10000 ) {
ab4351aa	134	AliError("Max number of authorized QA objects is 10000") ;
eca4fa66	135	} else {
eca4fa66	136	hist->SetDirectory(0) ;
750730d8	137	if (expert)
7d297381	138	hist->SetBit(AliQAv1::GetExpertBit()) ;
	139	if (image)
	140	hist->SetBit(AliQAv1::GetImageBit()) ;
eca4fa66	141	const Char_t * name = Form("%s_%s", AliRecoParam::GetEventSpecieName(fEventSpecie), hist->GetName()) ;
	142	hist->SetName(name) ;
	143	if(saveForCorr) {
	144	const Char_t * cname = Form("%s_%s", list[AliRecoParam::AConvert(AliRecoParam::kDefault)]->GetName(), hist->GetName()) ;
	145	TParameter<double> * p = new TParameter<double>(cname, 9999.9999) ;
	146	if ( fParameterList[AliRecoParam::AConvert(fEventSpecie)] == NULL )
	147	fParameterList[AliRecoParam::AConvert(fEventSpecie)] = new TList() ;
	148	fParameterList[AliRecoParam::AConvert(fEventSpecie)]->Add(p) ;
a2b64fbd	149	}
eca4fa66	150	list[AliRecoParam::AConvert(fEventSpecie)]->AddAtAndExpand(hist, index) ;
eca4fa66	151	rv = list[AliRecoParam::AConvert(fEventSpecie)]->GetLast() ;
a2b64fbd	152	}
57acd2d2	153	return rv ;
	154	}
	155
	156	//____________________________________________________________________________
	157	TH1 * AliQADataMaker::CloneMe(TH1 * hist, Int_t specie) const
	158	{
	159	// clones a histogram
fec0891b	160	const Char_t * name = Form("%s_%s", AliRecoParam::GetEventSpecieName(specie), hist->GetName()) ;
eca4fa66	161	TH1 * hClone = static_cast<TH1 *>(hist->Clone(name)) ;
4e25ac79	162	if ( hist->TestBit(AliQAv1::GetExpertBit()) )
b2db43c5	163	hClone->SetBit(AliQAv1::GetExpertBit()) ;
	164	if ( hist->TestBit(AliQAv1::GetImageBit()) )
	165	hClone->SetBit(AliQAv1::GetImageBit()) ;
75373542	166	return hClone ;
421ab0fb	167	}
421ab0fb	168
96d67a8d	169	//____________________________________________________________________________
4e25ac79	170	void AliQADataMaker::DefaultEndOfDetectorCycle(AliQAv1::TASKINDEX_t task)
96d67a8d	171	{
	172	// this method must be oveloaded by detectors
	173	// sets the QA result to Fatal
4e25ac79	174	AliQAv1::Instance(AliQAv1::GetDetIndex(GetName())) ;
4e25ac79	175	AliQAv1 * qa = AliQAv1::Instance(task) ;
57acd2d2	176	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
4e25ac79	177	qa->Set(AliQAv1::kFATAL, specie) ;
	178	AliQAv1::GetQAResultFile()->cd() ;
	179	qa->Write(AliQAv1::GetQAName(), kWriteDelete) ;
	180	AliQAv1::GetQAResultFile()->Close() ;
96d67a8d	181	}
96d67a8d	182
421ab0fb	183	//____________________________________________________________________________
c65c502a	184	void AliQADataMaker::Finish() const
421ab0fb	185	{
96d67a8d	186	// write to the output File
d9cbd8fd	187	if (fOutput)
d9cbd8fd	188	fOutput->Close() ;
421ab0fb	189	}
	190
	191	//____________________________________________________________________________
57acd2d2	192	TObject * AliQADataMaker::GetData(TObjArray ** list, const Int_t index)
04236e67	193	{
04236e67	194	// Returns the QA object at index. Limit is 100.
76c42cb4	195	if ( ! list ) {
	196	AliError("Data list is NULL !!") ;
	197	return NULL ;
	198	}
5e232cd6	199
5e232cd6	200	SetEventSpecie(fEventSpecie) ;
eca4fa66	201	Int_t esindex = AliRecoParam::AConvert(fEventSpecie) ;
	202	TH1 * histClone = NULL ;
	203	if (list[esindex]) {
27773260	204	if ( index > 10000 ) {
27773260	205	AliError("Max number of authorized QA objects is 10000") ;
27773260	206	} else {
eca4fa66	207	if ( list[esindex]->At(index) ) {
	208	histClone = static_cast<TH1*>(list[esindex]->At(index)) ;
	209	}
	210	}
	211	}
	212	return histClone ;
27773260	213	}
7d297381	214
211a7313	215	//____________________________________________________________________________
	216	TObjArray* AliQADataMaker::Init(AliQAv1::TASKINDEX_t task, AliRecoParam::EventSpecie_t es, Int_t cycles)
	217	{
	218	// Initialializes and returns the QAData list for a given event specie
	219	TObjArray ** ar = Init(task, cycles) ;
	220	return ar[AliRecoParam::AConvert(es)] ;
	221	}
	222
fec0891b	223	//____________________________________________________________________________
eca4fa66	224	void AliQADataMaker::MakeTheImage( TObjArray ** list, AliQAv1::TASKINDEX_t task, const Char_t * mode)
fec0891b	225	{
fec0891b	226	// makes the QA image for sim and rec
eca4fa66	227	TIter next(list[AliRecoParam::AConvert(fEventSpecie)]) ;
fec0891b	228	TH1 * hdata = NULL ;
fec0891b	229	Int_t nImages = 0 ;
eca4fa66	230	while ( (hdata=static_cast<TH1 *>(next())) ) {
	231	TString cln(hdata->ClassName()) ;
	232	if ( ! cln.Contains("TH1") )
	233	continue ;
fec0891b	234	if ( hdata->TestBit(AliQAv1::GetImageBit()) )
	235	nImages++;
	236	}
	237	if ( nImages == 0 ) {
	238	AliWarning(Form("No histogram will be plotted for %s %s\n", GetName(), AliQAv1::GetTaskName(task).Data())) ;
	239	} else {
	240	AliDebug(AliQAv1::GetQADebugLevel(), Form("%d histograms will be plotted for %s %s\n", nImages, GetName(), AliQAv1::GetTaskName(task).Data())) ;
	241	for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
	242	if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(esIndex)) )
	243	continue ;
	244	const Char_t * title = Form("QA_%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(esIndex)) ;
	245	if ( !fImage[esIndex] ) {
	246	fImage[esIndex] = new TCanvas(title, title) ;
	247	}
	248	fImage[esIndex]->Clear() ;
	249	fImage[esIndex]->SetTitle(title) ;
	250	fImage[esIndex]->cd() ;
	251	TPaveText someText(0.015, 0.015, 0.98, 0.98) ;
	252	someText.AddText(title) ;
	253	someText.Draw() ;
	254	fImage[esIndex]->Print(Form("%s%s%d.%s", AliQAv1::GetImageFileName(), mode, fRun, AliQAv1::GetImageFileFormat())) ;
	255	fImage[esIndex]->Clear() ;
	256	Int_t nx = TMath::Sqrt(nImages) ;
	257	Int_t ny = nx ;
	258	if ( nx < TMath::Sqrt(nImages))
	259	ny++ ;
	260	fImage[esIndex]->Divide(nx, ny) ;
	261	TIter nexthist(list[esIndex]) ;
	262	TH1* hist = NULL ;
	263	Int_t npad = 1 ;
	264	fImage[esIndex]->cd(npad) ;
eca4fa66	265	while ( (hist=static_cast<TH1*>(nexthist())) ) {
	266	TString cln(hist->ClassName()) ;
	267	if ( ! cln.Contains("TH1") )
	268	continue ;
fec0891b	269	if(hist->TestBit(AliQAv1::GetImageBit())) {
	270	hist->Draw() ;
	271	fImage[esIndex]->cd(++npad) ;
	272	}
	273	}
	274	fImage[esIndex]->Print(Form("%s%s%d.%s", AliQAv1::GetImageFileName(), mode, fRun, AliQAv1::GetImageFileFormat())) ;
	275	}
	276	}
	277	}