[u/mrichter/AliRoot.git] / STEER / AliQADataMakerRec.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 notifce   *
 * 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 for Reconstruction
//  All data must be mergeable objects.
//  Y. Schutz CERN July 2007
//

// --- ROOT system ---
#include <TCanvas.h>
#include <TFile.h>
#include <TTree.h>
#include <TNtupleD.h>
#include <TObjArray.h>

// --- Standard library ---

// --- AliRoot header files ---
#include "AliCDBPath.h"
#include "AliCDBEntry.h"
#include "AliDetectorRecoParam.h"
#include "AliCDBManager.h"

#include "AliLog.h"
#include "AliQADataMakerRec.h"
#include "AliESDEvent.h"
#include "AliRawReader.h"

ClassImp(AliQADataMakerRec)
             
//____________________________________________________________________________ 
AliQADataMakerRec::AliQADataMakerRec(const char * name, const char * title) : 
  AliQADataMaker(name, title), 
  fDigitsQAList(NULL),
  fESDsQAList(NULL), 
  fRawsQAList(NULL), 
  fRecPointsQAList(NULL),
  fCorrNt(NULL), 
  fRecoParam(NULL) 
{
  // ctor
	fDetectorDirName = GetName() ; 
}

//____________________________________________________________________________ 
AliQADataMakerRec::AliQADataMakerRec(const AliQADataMakerRec& qadm) :
  AliQADataMaker(qadm.GetName(), qadm.GetTitle()), 
  fDigitsQAList(qadm.fDigitsQAList),
  fESDsQAList(qadm.fESDsQAList),
  fRawsQAList(qadm.fRawsQAList),
  fRecPointsQAList(qadm.fRecPointsQAList),
  fCorrNt(qadm.fCorrNt),  
  fRecoParam(qadm.fRecoParam) 
{
  //copy ctor
 	SetName(qadm.GetName()) ; 
	SetTitle(qadm.GetTitle()) ; 
	fDetectorDirName = GetName() ; 
}

//____________________________________________________________________________ 
AliQADataMakerRec::~AliQADataMakerRec()
{
	//dtor: delete the TObjArray and thei content
	if ( fESDsQAList ) {
    for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
      if ( fESDsQAList[specie] ) {
        if ( fESDsQAList[specie]->IsOwner() ) 
          fESDsQAList[specie]->Delete() ;     
      }
    }
    delete[] fESDsQAList ;
	}
	if ( fRawsQAList ) {
    for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
      if ( fRawsQAList[specie] ) {
        if ( fRawsQAList[specie]->IsOwner() ) 
          fRawsQAList[specie]->Delete() ;
      }
    }
    delete[] fRawsQAList ;
  }
	if ( fDigitsQAList ) {
    for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
      if ( fDigitsQAList[specie] ) {
        if ( fDigitsQAList[specie]->IsOwner() ) 
          fDigitsQAList[specie]->Delete() ;
      }
    }
		delete[] fDigitsQAList ; 
  }
	if ( fRecPointsQAList ) {
    for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
      if ( fRecPointsQAList[specie] ) {
        if ( fRecPointsQAList[specie]->IsOwner() ) 
          fRecPointsQAList[specie]->Delete() ;
      }
    }
		delete[] fRecPointsQAList ; 
  }
}

//__________________________________________________________________
AliQADataMakerRec& AliQADataMakerRec::operator = (const AliQADataMakerRec& qadm )
{
  // Assignment operator.
  this->~AliQADataMakerRec();
  new(this) AliQADataMakerRec(qadm);
  return *this;
}

//____________________________________________________________________________
void AliQADataMakerRec::EndOfCycle() 
{
  // Finishes a cycle of QA for all the tasks
  EndOfCycle(AliQAv1::kRAWS) ; 
  EndOfCycle(AliQAv1::kDIGITSR) ; 
  EndOfCycle(AliQAv1::kRECPOINTS) ; 
  EndOfCycle(AliQAv1::kESDS) ; 
  ResetCycle() ; 
}

//____________________________________________________________________________
void AliQADataMakerRec::EndOfCycle(AliQAv1::TASKINDEX_t task) 
{
	// Finishes a cycle of QA 
	
	TObjArray ** list = NULL ; 
	
	if ( task == AliQAv1::kRAWS )     
		list = fRawsQAList ; 
	else if ( task == AliQAv1::kDIGITSR ) 
		list = fDigitsQAList ; 
	else if ( task == AliQAv1::kRECPOINTS ) 
		list = fRecPointsQAList ; 
	else if ( task == AliQAv1::kESDS )
		list = fESDsQAList ; 

 
	if ( ! list && ! fCorrNt ) 
    return ; 
  //DefaultEndOfDetectorCycle(task) ;
	EndOfDetectorCycle(task, list) ;
  fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ; 
  if (!fDetectorDir)
    fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ; 
  TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ; 
  if (!subDir)
    subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;  
  subDir->cd() ; 
  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
    if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)) ) 
      continue ; 
    TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(specie)) ;
    if (!eventSpecieDir) 
      eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(specie)) ; 
    eventSpecieDir->cd() ;    
    if (list[specie]) {
      TIter next(list[specie]) ; 
      TObject * obj ; 
      while( (obj = next()) ) {
        if (!obj->TestBit(AliQAv1::GetExpertBit()))
          obj->Write() ;
      }
      if (WriteExpert()) {
        TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ; 
        if (!expertDir)
          expertDir = eventSpecieDir->mkdir(AliQAv1::GetExpert()) ; 
        expertDir->cd() ;
        next.Reset() ; 
        while( (obj = next()) ) {
          if (!obj->TestBit(AliQAv1::GetExpertBit()))
            continue ; 
          obj->Write() ;
        }      
      }
    }
    if ( !fCorrNt )
      continue ; 
    if (fCorrNt[specie] && AliQAv1::GetDetIndex(GetName()) == AliQAv1::kCORR) {
      eventSpecieDir->cd() ; 
      fCorrNt[specie]->Write() ; 
    }
    fOutput->Save() ; 
  }
  MakeImage(task) ; 
}

//____________________________________________________________________________ 
void AliQADataMakerRec::MakeImage(AliQAv1::TASKINDEX_t task)
{
  // create a drawing of detetor defined histograms
  TObjArray ** list = NULL ;  
  switch (task) {
    case AliQAv1::kRAWS:
      list = fRawsQAList ; 
      break;
    case AliQAv1::kHITS:
      break;
    case AliQAv1::kSDIGITS:
      break;  
    case AliQAv1::kDIGITS:
      break;  
    case AliQAv1::kDIGITSR:
      list = fDigitsQAList ; 
      break;  
    case AliQAv1::kRECPOINTS:
      list = fRecPointsQAList ; 
      break;
    case AliQAv1::kTRACKSEGMENTS:
      break;
    case AliQAv1::kRECPARTICLES:
      break;
    case AliQAv1::kESDS:
      list = fESDsQAList ; 
      break;
    case AliQAv1::kNTASKINDEX:
      break;
    default:
      break;
  }
  if ( !list) {
    AliError("data not initialized, call AliQADataMaker::Init"); 
    return ; 
  }
  MakeTheImage(list, task, "Rec") ; 
}

//____________________________________________________________________________
void AliQADataMakerRec::Exec(AliQAv1::TASKINDEX_t task, TObject * data) 
{ 
  // creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs)
	
	if ( task == AliQAv1::kRAWS ) {
		AliDebug(AliQAv1::GetQADebugLevel(), "Processing Raws QA") ; 
		AliRawReader * rawReader = static_cast<AliRawReader *>(data) ; 
		if (rawReader) 
			MakeRaws(rawReader) ;
		else
      AliDebug(AliQAv1::GetQADebugLevel(), "Raw data are not processed") ;     
	} else if ( task == AliQAv1::kDIGITSR ) {
		AliDebug(AliQAv1::GetQADebugLevel(), "Processing Digits QA") ; 
		TTree * tree = static_cast<TTree *>(data) ; 
		if (strcmp(tree->ClassName(), "TTree") == 0) {
			MakeDigits(tree) ; 
		} else {
			AliWarning("data are not a TTree") ; 
		}
	} else if ( task == AliQAv1::kRECPOINTS ) {
		AliDebug(AliQAv1::GetQADebugLevel(), "Processing RecPoints QA") ; 
		TTree * tree = static_cast<TTree *>(data) ; 
		if (strcmp(tree->ClassName(), "TTree") == 0) {
			MakeRecPoints(tree) ; 
		} else {
			AliWarning("data are not a TTree") ; 
		}
	} else if ( task == AliQAv1::kESDS ) {
		AliDebug(AliQAv1::GetQADebugLevel(), "Processing ESDs QA") ; 
		AliESDEvent * esd = static_cast<AliESDEvent *>(data) ; 
		if (strcmp(esd->ClassName(), "AliESDEvent") == 0) 
			MakeESDs(esd) ;
		else 
			AliError("Wrong type of esd container") ; 
	}  
}

//____________________________________________________________________________ 
TObjArray **  AliQADataMakerRec::Init(AliQAv1::TASKINDEX_t task, Int_t cycles)
{
  // general intialisation
  InitRecoParams() ;
	TObjArray ** rv = NULL ; 
  
	if (cycles > 0)
		SetCycle(cycles) ;  
	
	if ( task == AliQAv1::kRAWS ) {
		if (! fRawsQAList ) { 
      fRawsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
      for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
        fRawsQAList[specie] = new TObjArray(1) ;	 
        fRawsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
      }
		}
		rv = fRawsQAList ;
	} else if ( task == AliQAv1::kDIGITSR ) {
		if ( ! fDigitsQAList ) {
      fDigitsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
      for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
        fDigitsQAList[specie] = new TObjArray(1) ; 
        fDigitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
      }
		}
		rv = fDigitsQAList ;
	} else if ( task == AliQAv1::kRECPOINTS ) {
		if ( ! fRecPointsQAList ) {
      fRecPointsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
      for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
        fRecPointsQAList[specie] = new TObjArray(1) ; 
        fRecPointsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
      }
    }
		rv = fRecPointsQAList ;
	} else if ( task == AliQAv1::kESDS ) {
		if ( ! fESDsQAList ) {
      fESDsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
      for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
        fESDsQAList[specie] = new TObjArray(1) ;
        fESDsQAList[specie]->SetName(Form("%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
      }
		}
		rv = fESDsQAList ;
	}
	return rv ; 
}

//____________________________________________________________________________ 
void AliQADataMakerRec::Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles)
{
  // Intialisation by passing the list of QA data booked elsewhere
  
  InitRecoParams() ;
  fRun = run ;
	if (cycles > 0)
		SetCycle(cycles) ;  
	
	if ( task == AliQAv1::kRAWS ) {
		fRawsQAList = list ;	 
	} else if ( task == AliQAv1::kDIGITSR ) {
		fDigitsQAList = list ; 
	} else if ( task == AliQAv1::kRECPOINTS ) {
		fRecPointsQAList = list ; 
	} else if ( task == AliQAv1::kESDS ) {
		fESDsQAList = list ; 
	}
}

//____________________________________________________________________________
void AliQADataMakerRec::InitRecoParams() 
{
  if (!fRecoParam) {
    AliDebug(AliQAv1::GetQADebugLevel(), Form("Loading reconstruction parameter objects for detector %s", GetName()));
    AliCDBPath path(GetName(),"Calib","RecoParam");
    AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
    if(!entry) {
      fRecoParam = NULL ; 
      AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",GetName()));
    }
    else {
      TObject * recoParamObj = entry->GetObject() ; 
      if ( strcmp(recoParamObj->ClassName(), "TObjArray") == 0 ) {
        // The detector has only one set of reco parameters
        AliDebug(AliQAv1::GetQADebugLevel(), Form("Array of reconstruction parameters found for detector %s",GetName()));
        TObjArray *recoParamArray = static_cast<TObjArray*>(recoParamObj) ;
        for (Int_t iRP=0; iRP<recoParamArray->GetEntriesFast(); iRP++) {
          fRecoParam = static_cast<AliDetectorRecoParam*>(recoParamArray->At(iRP)) ;
          if (!fRecoParam) 
            break ; 
          else if (fRecoParam->IsDefault()) 
            break ; 
        }
      }
      else if (recoParamObj->InheritsFrom("AliDetectorRecoParam")) {
        // The detector has only one set of reco parameters
        // Registering it in AliRecoParam
        AliDebug(AliQAv1::GetQADebugLevel(), Form("Single set of reconstruction parameters found for detector %s",GetName()));
        fRecoParam = static_cast<AliDetectorRecoParam*>(recoParamObj) ;
        static_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
      } else { 
        AliError(Form("No valid RecoParam object found in the OCDB for detector %s",GetName()));
      }
    }
    AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
  }
}

//____________________________________________________________________________
void AliQADataMakerRec::StartOfCycle(Int_t run) 
{
  // Finishes a cycle of QA for all the tasks
  Bool_t samecycle = kFALSE ; 
  StartOfCycle(AliQAv1::kRAWS,      run, samecycle) ;
  samecycle = kTRUE ; 
  StartOfCycle(AliQAv1::kDIGITSR,   run, samecycle) ; 
  StartOfCycle(AliQAv1::kRECPOINTS, run, samecycle) ; 
  StartOfCycle(AliQAv1::kESDS,      run, samecycle) ; 
}

//____________________________________________________________________________
void AliQADataMakerRec::StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle) 
{ 
  // Finishes a cycle of QA data acquistion
  if ( run > 0 ) 
    fRun = run ; 
	if ( !sameCycle || fCurrentCycle == -1) {
		ResetCycle() ;
		if (fOutput) 
			fOutput->Close() ; 
		fOutput = AliQAv1::GetQADataFile(GetName(), fRun) ; 	
	}	
	AliDebug(AliQAv1::GetQADebugLevel(), Form(" Run %d Cycle %d task %s file %s", 
				 fRun, fCurrentCycle, AliQAv1::GetTaskName(task).Data(), fOutput->GetName() )) ;

//	fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ; 
//	if (!fDetectorDir)
//		fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ; 
//  
//	TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ; 
//	if (!subDir)
//		subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;  
//  
//  for ( Int_t specie = AliRecoParam::kDefault ; specie < AliRecoParam::kNSpecies ; specie++ ) {
//    TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(specie)) ; 
//    if (!eventSpecieDir) 
//      eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(specie)) ; 
//    TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ; 
//    if (!expertDir)
//      expertDir = eventSpecieDir->mkdir(AliQAv1::GetExpert()) ; 
//  } 
	StartOfDetectorCycle() ; 
}
Commit	Line	Data
	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 notifce *
	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
	19	//
	20	// Base Class
	21	// Produces the data needed to calculate the quality assurance for Reconstruction
	22	// All data must be mergeable objects.
	23	// Y. Schutz CERN July 2007
	24	//
	25
	26	// --- ROOT system ---
	27	#include <TCanvas.h>
	28	#include <TFile.h>
	29	#include <TTree.h>
	30	#include <TNtupleD.h>
	31	#include <TObjArray.h>
	32
	33	// --- Standard library ---
	34
	35	// --- AliRoot header files ---
	36	#include "AliCDBPath.h"
	37	#include "AliCDBEntry.h"
	38	#include "AliDetectorRecoParam.h"
	39	#include "AliCDBManager.h"
	40
	41	#include "AliLog.h"
	42	#include "AliQADataMakerRec.h"
	43	#include "AliESDEvent.h"
	44	#include "AliRawReader.h"
	45
	46	ClassImp(AliQADataMakerRec)
	47
	48	//____________________________________________________________________________
	49	AliQADataMakerRec::AliQADataMakerRec(const char * name, const char * title) :
	50	AliQADataMaker(name, title),
	51	fDigitsQAList(NULL),
	52	fESDsQAList(NULL),
	53	fRawsQAList(NULL),
	54	fRecPointsQAList(NULL),
	55	fCorrNt(NULL),
	56	fRecoParam(NULL)
	57	{
	58	// ctor
	59	fDetectorDirName = GetName() ;
	60	}
	61
	62	//____________________________________________________________________________
	63	AliQADataMakerRec::AliQADataMakerRec(const AliQADataMakerRec& qadm) :
	64	AliQADataMaker(qadm.GetName(), qadm.GetTitle()),
	65	fDigitsQAList(qadm.fDigitsQAList),
	66	fESDsQAList(qadm.fESDsQAList),
	67	fRawsQAList(qadm.fRawsQAList),
	68	fRecPointsQAList(qadm.fRecPointsQAList),
	69	fCorrNt(qadm.fCorrNt),
	70	fRecoParam(qadm.fRecoParam)
	71	{
	72	//copy ctor
	73	SetName(qadm.GetName()) ;
	74	SetTitle(qadm.GetTitle()) ;
	75	fDetectorDirName = GetName() ;
	76	}
	77
	78	//____________________________________________________________________________
	79	AliQADataMakerRec::~AliQADataMakerRec()
	80	{
	81	//dtor: delete the TObjArray and thei content
	82	if ( fESDsQAList ) {
	83	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
	84	if ( fESDsQAList[specie] ) {
	85	if ( fESDsQAList[specie]->IsOwner() )
	86	fESDsQAList[specie]->Delete() ;
	87	}
	88	}
	89	delete[] fESDsQAList ;
	90	}
	91	if ( fRawsQAList ) {
	92	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
	93	if ( fRawsQAList[specie] ) {
	94	if ( fRawsQAList[specie]->IsOwner() )
	95	fRawsQAList[specie]->Delete() ;
	96	}
	97	}
	98	delete[] fRawsQAList ;
	99	}
	100	if ( fDigitsQAList ) {
	101	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
	102	if ( fDigitsQAList[specie] ) {
	103	if ( fDigitsQAList[specie]->IsOwner() )
	104	fDigitsQAList[specie]->Delete() ;
	105	}
	106	}
	107	delete[] fDigitsQAList ;
	108	}
	109	if ( fRecPointsQAList ) {
	110	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
	111	if ( fRecPointsQAList[specie] ) {
	112	if ( fRecPointsQAList[specie]->IsOwner() )
	113	fRecPointsQAList[specie]->Delete() ;
	114	}
	115	}
	116	delete[] fRecPointsQAList ;
	117	}
	118	}
	119
	120	//__________________________________________________________________
	121	AliQADataMakerRec& AliQADataMakerRec::operator = (const AliQADataMakerRec& qadm )
	122	{
	123	// Assignment operator.
	124	this->~AliQADataMakerRec();
	125	new(this) AliQADataMakerRec(qadm);
	126	return *this;
	127	}
	128
	129	//____________________________________________________________________________
	130	void AliQADataMakerRec::EndOfCycle()
	131	{
	132	// Finishes a cycle of QA for all the tasks
	133	EndOfCycle(AliQAv1::kRAWS) ;
	134	EndOfCycle(AliQAv1::kDIGITSR) ;
	135	EndOfCycle(AliQAv1::kRECPOINTS) ;
	136	EndOfCycle(AliQAv1::kESDS) ;
	137	ResetCycle() ;
	138	}
	139
	140	//____________________________________________________________________________
	141	void AliQADataMakerRec::EndOfCycle(AliQAv1::TASKINDEX_t task)
	142	{
	143	// Finishes a cycle of QA
	144
	145	TObjArray ** list = NULL ;
	146
	147	if ( task == AliQAv1::kRAWS )
	148	list = fRawsQAList ;
	149	else if ( task == AliQAv1::kDIGITSR )
	150	list = fDigitsQAList ;
	151	else if ( task == AliQAv1::kRECPOINTS )
	152	list = fRecPointsQAList ;
	153	else if ( task == AliQAv1::kESDS )
	154	list = fESDsQAList ;
	155
	156
	157	if ( ! list && ! fCorrNt )
	158	return ;
	159	//DefaultEndOfDetectorCycle(task) ;
	160	EndOfDetectorCycle(task, list) ;
	161	fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ;
	162	if (!fDetectorDir)
	163	fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ;
	164	TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ;
	165	if (!subDir)
	166	subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;
	167	subDir->cd() ;
	168	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
	169	if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)) )
	170	continue ;
	171	TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(specie)) ;
	172	if (!eventSpecieDir)
	173	eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(specie)) ;
	174	eventSpecieDir->cd() ;
	175	if (list[specie]) {
	176	TIter next(list[specie]) ;
	177	TObject * obj ;
	178	while( (obj = next()) ) {
	179	if (!obj->TestBit(AliQAv1::GetExpertBit()))
	180	obj->Write() ;
	181	}
	182	if (WriteExpert()) {
	183	TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ;
	184	if (!expertDir)
	185	expertDir = eventSpecieDir->mkdir(AliQAv1::GetExpert()) ;
	186	expertDir->cd() ;
	187	next.Reset() ;
	188	while( (obj = next()) ) {
	189	if (!obj->TestBit(AliQAv1::GetExpertBit()))
	190	continue ;
	191	obj->Write() ;
	192	}
	193	}
	194	}
	195	if ( !fCorrNt )
	196	continue ;
	197	if (fCorrNt[specie] && AliQAv1::GetDetIndex(GetName()) == AliQAv1::kCORR) {
	198	eventSpecieDir->cd() ;
	199	fCorrNt[specie]->Write() ;
	200	}
	201	fOutput->Save() ;
	202	}
	203	MakeImage(task) ;
	204	}
	205
	206	//____________________________________________________________________________
	207	void AliQADataMakerRec::MakeImage(AliQAv1::TASKINDEX_t task)
	208	{
	209	// create a drawing of detetor defined histograms
	210	TObjArray ** list = NULL ;
	211	switch (task) {
	212	case AliQAv1::kRAWS:
	213	list = fRawsQAList ;
	214	break;
	215	case AliQAv1::kHITS:
	216	break;
	217	case AliQAv1::kSDIGITS:
	218	break;
	219	case AliQAv1::kDIGITS:
	220	break;
	221	case AliQAv1::kDIGITSR:
	222	list = fDigitsQAList ;
	223	break;
	224	case AliQAv1::kRECPOINTS:
	225	list = fRecPointsQAList ;
	226	break;
	227	case AliQAv1::kTRACKSEGMENTS:
	228	break;
	229	case AliQAv1::kRECPARTICLES:
	230	break;
	231	case AliQAv1::kESDS:
	232	list = fESDsQAList ;
	233	break;
	234	case AliQAv1::kNTASKINDEX:
	235	break;
	236	default:
	237	break;
	238	}
	239	if ( !list) {
	240	AliError("data not initialized, call AliQADataMaker::Init");
	241	return ;
	242	}
	243	MakeTheImage(list, task, "Rec") ;
	244	}
	245
	246	//____________________________________________________________________________
	247	void AliQADataMakerRec::Exec(AliQAv1::TASKINDEX_t task, TObject * data)
	248	{
	249	// creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs)
	250
	251	if ( task == AliQAv1::kRAWS ) {
	252	AliDebug(AliQAv1::GetQADebugLevel(), "Processing Raws QA") ;
	253	AliRawReader * rawReader = static_cast<AliRawReader *>(data) ;
	254	if (rawReader)
	255	MakeRaws(rawReader) ;
	256	else
	257	AliDebug(AliQAv1::GetQADebugLevel(), "Raw data are not processed") ;
	258	} else if ( task == AliQAv1::kDIGITSR ) {
	259	AliDebug(AliQAv1::GetQADebugLevel(), "Processing Digits QA") ;
	260	TTree * tree = static_cast<TTree *>(data) ;
	261	if (strcmp(tree->ClassName(), "TTree") == 0) {
	262	MakeDigits(tree) ;
	263	} else {
	264	AliWarning("data are not a TTree") ;
	265	}
	266	} else if ( task == AliQAv1::kRECPOINTS ) {
	267	AliDebug(AliQAv1::GetQADebugLevel(), "Processing RecPoints QA") ;
	268	TTree * tree = static_cast<TTree *>(data) ;
	269	if (strcmp(tree->ClassName(), "TTree") == 0) {
	270	MakeRecPoints(tree) ;
	271	} else {
	272	AliWarning("data are not a TTree") ;
	273	}
	274	} else if ( task == AliQAv1::kESDS ) {
	275	AliDebug(AliQAv1::GetQADebugLevel(), "Processing ESDs QA") ;
	276	AliESDEvent * esd = static_cast<AliESDEvent *>(data) ;
	277	if (strcmp(esd->ClassName(), "AliESDEvent") == 0)
	278	MakeESDs(esd) ;
	279	else
	280	AliError("Wrong type of esd container") ;
	281	}
	282	}
	283
	284	//____________________________________________________________________________
	285	TObjArray ** AliQADataMakerRec::Init(AliQAv1::TASKINDEX_t task, Int_t cycles)
	286	{
	287	// general intialisation
	288	InitRecoParams() ;
	289	TObjArray ** rv = NULL ;
	290
	291	if (cycles > 0)
	292	SetCycle(cycles) ;
	293
	294	if ( task == AliQAv1::kRAWS ) {
	295	if (! fRawsQAList ) {
	296	fRawsQAList = new TObjArray *[AliRecoParam::kNSpecies] ;
	297	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
	298	fRawsQAList[specie] = new TObjArray(1) ;
	299	fRawsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
	300	}
	301	}
	302	rv = fRawsQAList ;
	303	} else if ( task == AliQAv1::kDIGITSR ) {
	304	if ( ! fDigitsQAList ) {
	305	fDigitsQAList = new TObjArray *[AliRecoParam::kNSpecies] ;
	306	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
	307	fDigitsQAList[specie] = new TObjArray(1) ;
	308	fDigitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
	309	}
	310	}
	311	rv = fDigitsQAList ;
	312	} else if ( task == AliQAv1::kRECPOINTS ) {
	313	if ( ! fRecPointsQAList ) {
	314	fRecPointsQAList = new TObjArray *[AliRecoParam::kNSpecies] ;
	315	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
	316	fRecPointsQAList[specie] = new TObjArray(1) ;
	317	fRecPointsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
	318	}
	319	}
	320	rv = fRecPointsQAList ;
	321	} else if ( task == AliQAv1::kESDS ) {
	322	if ( ! fESDsQAList ) {
	323	fESDsQAList = new TObjArray *[AliRecoParam::kNSpecies] ;
	324	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
	325	fESDsQAList[specie] = new TObjArray(1) ;
	326	fESDsQAList[specie]->SetName(Form("%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
	327	}
	328	}
	329	rv = fESDsQAList ;
	330	}
	331	return rv ;
	332	}
	333
	334	//____________________________________________________________________________
	335	void AliQADataMakerRec::Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles)
	336	{
	337	// Intialisation by passing the list of QA data booked elsewhere
	338
	339	InitRecoParams() ;
	340	fRun = run ;
	341	if (cycles > 0)
	342	SetCycle(cycles) ;
	343
	344	if ( task == AliQAv1::kRAWS ) {
	345	fRawsQAList = list ;
	346	} else if ( task == AliQAv1::kDIGITSR ) {
	347	fDigitsQAList = list ;
	348	} else if ( task == AliQAv1::kRECPOINTS ) {
	349	fRecPointsQAList = list ;
	350	} else if ( task == AliQAv1::kESDS ) {
	351	fESDsQAList = list ;
	352	}
	353	}
	354
	355	//____________________________________________________________________________
	356	void AliQADataMakerRec::InitRecoParams()
	357	{
	358	if (!fRecoParam) {
	359	AliDebug(AliQAv1::GetQADebugLevel(), Form("Loading reconstruction parameter objects for detector %s", GetName()));
	360	AliCDBPath path(GetName(),"Calib","RecoParam");
	361	AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
	362	if(!entry) {
	363	fRecoParam = NULL ;
	364	AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",GetName()));
	365	}
	366	else {
	367	TObject * recoParamObj = entry->GetObject() ;
	368	if ( strcmp(recoParamObj->ClassName(), "TObjArray") == 0 ) {
	369	// The detector has only one set of reco parameters
	370	AliDebug(AliQAv1::GetQADebugLevel(), Form("Array of reconstruction parameters found for detector %s",GetName()));
	371	TObjArray recoParamArray = static_cast<TObjArray>(recoParamObj) ;
	372	for (Int_t iRP=0; iRP<recoParamArray->GetEntriesFast(); iRP++) {
	373	fRecoParam = static_cast<AliDetectorRecoParam*>(recoParamArray->At(iRP)) ;
	374	if (!fRecoParam)
	375	break ;
	376	else if (fRecoParam->IsDefault())
	377	break ;
	378	}
	379	}
	380	else if (recoParamObj->InheritsFrom("AliDetectorRecoParam")) {
	381	// The detector has only one set of reco parameters
	382	// Registering it in AliRecoParam
	383	AliDebug(AliQAv1::GetQADebugLevel(), Form("Single set of reconstruction parameters found for detector %s",GetName()));
	384	fRecoParam = static_cast<AliDetectorRecoParam*>(recoParamObj) ;
	385	static_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
	386	} else {
	387	AliError(Form("No valid RecoParam object found in the OCDB for detector %s",GetName()));
	388	}
	389	}
	390	AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
	391	}
	392	}
	393
	394	//____________________________________________________________________________
	395	void AliQADataMakerRec::StartOfCycle(Int_t run)
	396	{
	397	// Finishes a cycle of QA for all the tasks
	398	Bool_t samecycle = kFALSE ;
	399	StartOfCycle(AliQAv1::kRAWS, run, samecycle) ;
	400	samecycle = kTRUE ;
	401	StartOfCycle(AliQAv1::kDIGITSR, run, samecycle) ;
	402	StartOfCycle(AliQAv1::kRECPOINTS, run, samecycle) ;
	403	StartOfCycle(AliQAv1::kESDS, run, samecycle) ;
	404	}
	405
	406	//____________________________________________________________________________
	407	void AliQADataMakerRec::StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle)
	408	{
	409	// Finishes a cycle of QA data acquistion
	410	if ( run > 0 )
	411	fRun = run ;
	412	if ( !sameCycle \|\| fCurrentCycle == -1) {
	413	ResetCycle() ;
	414	if (fOutput)
	415	fOutput->Close() ;
	416	fOutput = AliQAv1::GetQADataFile(GetName(), fRun) ;
	417	}
	418	AliDebug(AliQAv1::GetQADebugLevel(), Form(" Run %d Cycle %d task %s file %s",
	419	fRun, fCurrentCycle, AliQAv1::GetTaskName(task).Data(), fOutput->GetName() )) ;
	420
	421	// fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ;
	422	// if (!fDetectorDir)
	423	// fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ;
	424	//
	425	// TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ;
	426	// if (!subDir)
	427	// subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;
	428	//
	429	// for ( Int_t specie = AliRecoParam::kDefault ; specie < AliRecoParam::kNSpecies ; specie++ ) {
	430	// TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(specie)) ;
	431	// if (!eventSpecieDir)
	432	// eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(specie)) ;
	433	// TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ;
	434	// if (!expertDir)
	435	// expertDir = eventSpecieDir->mkdir(AliQAv1::GetExpert()) ;
	436	// }
	437	StartOfDetectorCycle() ;
	438	}