[u/mrichter/AliRoot.git] / EMCAL / AliEMCALQAChecker.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.                  *
 **************************************************************************/

/*
  Checks the quality assurance. 
  By comparing with reference data

  Based on PHOS code written by
  Y. Schutz CERN July 2007

 For the moment we only implement the checking of raw data QA.
 The checked for ESD and RecPoints will be implemented later.
 

 */


// --- ROOT system ---
#include <TClass.h>
#include <TH1.h> 
#include <TF1.h> 
#include <TH1I.h> 
#include <TH2F.h>
#include <TIterator.h> 
#include <TKey.h> 
#include <TFile.h> 
#include <TLine.h>
#include <TText.h>
#include <TPaveText.h>
#include <TMath.h>

// --- Standard library ---

// --- AliRoot header files ---
#include "AliLog.h"
#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliEMCALQAChecker.h"

ClassImp(AliEMCALQAChecker)

//__________________________________________________________________
AliEMCALQAChecker::AliEMCALQAChecker() : 
AliQACheckerBase("EMCAL","EMCAL Quality Assurance Data Maker"),
fTextSM(new TText*[fgknSM]),
fLineCol(new TLine(47.5,-0.5,47.5,119.5)),
fText(new TPaveText(0.2,0.7,0.8,0.9,"NDC"))
{
  // ctor
  fLineCol->SetLineColor(1);
  fLineCol->SetLineWidth(2);

  fTextSM[0]= new TText(20, 12, "SM A0");
  fTextSM[1]= new TText(20, 36, "SM A1");
  fTextSM[2]= new TText(20, 60, "SM A2");
  fTextSM[3]= new TText(20, 84, "SM A3");
  fTextSM[4]= new TText(20, 108,"SM A4");
  fTextSM[5]= new TText(20, 132,"SM A5");

  fTextSM[6]= new TText(64, 12, "SM C0");
  fTextSM[7]= new TText(64, 36, "SM C1");
  fTextSM[8]= new TText(64, 60, "SM C2");
  fTextSM[9]= new TText(64, 84, "SM C3");
  fTextSM[10]= new TText(64, 108,"SM C4");
  fTextSM[11]= new TText(64, 132,"SM C5");

	for(int i = 0; i < 5; i++) {
		fLineRow[i] = new TLine(-0.5,23.5+(24*i),95.5,23.5+(24*i));
		fLineRow[i]->SetLineColor(1);
		fLineRow[i]->SetLineWidth(2);
	}

	for(int i = 0; i < 3; i++) {
		fTextL1[i] = new TPaveText(0.2,0.7,0.8,0.9,"NDC");
	}


}          

//__________________________________________________________________
AliEMCALQAChecker::~AliEMCALQAChecker() 
{
	/// dtor
  delete [] fTextSM ;
  delete fLineCol ;
  for (Int_t i=0; i<5; ++i) delete fLineRow[i] ;
  delete fText  ; 
}

//______________________________________________________________________________
void AliEMCALQAChecker::Check(Double_t * test, AliQAv1::ALITASK_t index, TObjArray ** list, const AliDetectorRecoParam * /*recoParam*/)
{
	/// Check objects in list
	
	if ( index == AliQAv1::kRAW ) 
	{
    CheckRaws(test, list);
		printf ("checkers for task %d \n", index) ;		
	}
	
	if ( index == AliQAv1::kREC)
	{
    CheckRecPoints(test, list);
	}
	
	if ( index == AliQAv1::kESD )
	{
    CheckESD(test, list);
	}
	AliWarning(Form("Checker for task %d not implement for the moment",index));
}

//______________________________________________________________________________
TH1* 
AliEMCALQAChecker::GetHisto(TObjArray* list, const char* hname, Int_t specie) const
{
	/// Get a given histo from the list
	TH1* h = static_cast<TH1*>(list->FindObject(Form("%s_%s",AliRecoParam::GetEventSpecieName(specie),hname)));
	if (!h)
	{
		AliError(Form("Did not find expected histo %s",hname));
	}
	return h;
}

//______________________________________________________________________________
Double_t 
AliEMCALQAChecker::MarkHisto(TH1& histo, Double_t value) const
{
	/// Mark histo as originator of some QA error/warning
	
	if ( value != 1.0 )
	{
		histo.SetBit(AliQAv1::GetQABit());
	}
	
	return value;
}


//______________________________________________________________________________
void AliEMCALQAChecker::CheckRaws(Double_t * test, TObjArray ** list)
{
  //  Check RAW QA histograms	
  //  -- Yaxian Mao, CCNU/CERN/LPSC
  //adding new checking method: 25/04/2010, Yaxian Mao
  //Comparing the amplitude from current run to the reference run, if the ratio in the range [0.8, .12], count as a good tower.
  //If more than 90% towers are good, EMCAL works fine, otherwise experts should be contacted. 
   				
  Int_t nTowersPerSM = 24*48; // number of towers in a SuperModule; 24x48
  Double_t nTot = fgknSM * nTowersPerSM ;
  TList *lstF = 0;
  Int_t calibSpecieId = (Int_t)TMath::Log2( AliRecoParam::kCalib );
  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
    test[specie] = 0.0 ; 
    if ( !AliQAv1::Instance()->IsEventSpecieSet(specie)) continue ; 
    if (list[specie]->GetEntries() == 0) test[specie] = 0. ; // nothing to check
    else {
			//get calib histos
			TH2F * hdata  = (TH2F*)list[specie]->At(k2DRatioAmp) ; 
			TH1F * ratio = (TH1F*)list[specie]->At(kRatioDist) ;
			
			//get L1 histos
			TH2F *hL1GammaPatch = (TH2F*)list[specie]->At(kGL1);
			TH2F *hL1JetPatch = (TH2F*)list[specie]->At(kJL1);
			TH1I *hFrameR = (TH1I*)list[specie]->At(kSTUTRU);

			//calib histo checker first:

      if(hdata->GetEntries()!=0 && ratio->GetEntries()!=0) {
				//adding the lines to distinguish different SMs
				lstF = hdata->GetListOfFunctions();
				CleanListOfFunctions(lstF);
				lstF->Add(fLineCol->Clone()); 
				for(Int_t iLine = 0; iLine < 4; iLine++) {
					lstF->Add(fLineRow[iLine]->Clone());
				} 
				//Now adding the text to for each SM
				for(Int_t iSM = 0 ; iSM < fgknSM ; iSM++){  //number of SMs loop start
					lstF->Add(fTextSM[iSM]->Clone()); 
				}
				//
				lstF = ratio->GetListOfFunctions();
				CleanListOfFunctions(lstF);
				//
				//now check the ratio histogram
				Double_t binContent = 0. ;  
				Int_t nGoodTower = 0 ;
				Double_t rv = 0. ;
				for(Int_t ix = 1; ix <= hdata->GetNbinsX(); ix++) {
					for(Int_t iy = 1; iy <= hdata->GetNbinsY(); iy++) {
						binContent = hdata->GetBinContent(ix, iy) ; 
						if (binContent < 1.2 && binContent > 0.8) nGoodTower++ ;
					}
				}
				rv = nGoodTower/nTot ; 
				printf("%2.2f %% towers out of range [0.8, 1.2]\n", (1-rv)*100);
				if(fText){
					lstF->Add(fText->Clone()) ;
					fText->Clear() ; 
        
					fText->AddText(Form("%2.2f %% towers out of range [0.8, 1.2]", (1-rv)*100));     
					if (rv < 0.9) {
						test[specie] = 0.9 ;
						// 2 lines text info for quality         
						fText->SetFillColor(2) ;
						fText->AddText(Form("EMCAL = NOK, CALL EXPERTS!!!")); 
					}
					else {
						test[specie] = 0.1 ;
						fText->SetFillColor(3) ;
						fText->AddText(Form("EMCAL = OK, ENJOY...")); 
					}
				}//fText
			} // calib histo checking done

			//now L1 checks:
      if (specie != calibSpecieId) {
			if(hL1GammaPatch->GetEntries() !=0 ) {
				lstF = hL1GammaPatch->GetListOfFunctions();
				CleanListOfFunctions(lstF);


				//Checker for L1GammaPatch (if a patch triggers > sigmaG * mean value (1/#patch positions total) says "hot spot !")
				Double_t dL1GmeanTrig = 1/2961.; 
				Int_t sigmaG = 5; // deviation from mean value
				Double_t dL1GEntries = hL1GammaPatch->GetEntries();
				Int_t badL1G[48][64] = {{0}} ;
				Int_t nBadL1G = 0;
				for(Int_t ix = 1; ix <=  hL1GammaPatch->GetNbinsX(); ix++) {
					for(Int_t iy = 1; iy <=  hL1GammaPatch->GetNbinsY(); iy++) {
						Double_t binContent = hL1GammaPatch->GetBinContent(ix, iy) ; 
						if (binContent != 0) {
							if ((double)binContent/(double)dL1GEntries > sigmaG*dL1GmeanTrig) {
								badL1G[ix-1][iy-1] += 1;
								nBadL1G += 1;
							}
						}
					}
				}

				if(fTextL1[0]){
					lstF->Add(fTextL1[0]->Clone()) ;
					fTextL1[0]->Clear() ; 

					if (nBadL1G == 0) {
						fTextL1[0]->SetFillColor(3) ;
						fTextL1[0]->AddText(Form("L1 GAMMA TRIGGER = OK, ENJOY...")); 
					}
					else {
						fTextL1[0]->SetFillColor(2) ;
						fTextL1[0]->AddText(Form("HOT SPOT IN L1 GAMMA TRIGGER = CALL EXPERT!!"));
/*
						for(Int_t ix = 1; ix <=  hL1GammaPatch->GetNbinsX(); ix++) {
							for(Int_t iy = 1; iy <=  hL1GammaPatch->GetNbinsY(); iy++) {
								if(badL1G[ix-1][iy-1] != 0) printf("L1 Gamma patch with position x = %d, y = %d is out of range\n",ix,iy);
							}
						}
*/
					}
				}//fTextL1[0]
			}// L1 gamma patch checking done

			if(hL1JetPatch->GetEntries() !=0) {
				lstF = hL1JetPatch->GetListOfFunctions();
				CleanListOfFunctions(lstF);
			
				//Checker for L1JetPatch (if a patch triggers > sigmaJ * mean value (1/#patch positions total) says "hot spot !")
				Double_t dL1JmeanTrig = 1/126.;
				Int_t sigmaJ = 5; // deviation from  mean value
				Double_t dL1JEntries = hL1JetPatch->GetEntries();
				Int_t badL1J[12][16] = {{0}} ;
				Int_t nBadL1J = 0;
				for(Int_t ix = 1; ix <=  hL1JetPatch->GetNbinsX(); ix++) {
					for(Int_t iy = 1; iy <=  hL1JetPatch->GetNbinsY(); iy++) {
						Double_t binContent = hL1JetPatch->GetBinContent(ix, iy) ; 
						if (binContent != 0) {
							if ((double)binContent/(double)dL1JEntries > sigmaJ*dL1JmeanTrig) {
								badL1J[ix-1][iy-1] += 1 ;
								nBadL1J += 1;
							}
						}
					}
				}

				if(fTextL1[1]){
					lstF->Add(fTextL1[1]->Clone()) ;
					fTextL1[1]->Clear() ; 

					if (nBadL1J == 0) {
						fTextL1[1]->SetFillColor(3) ;
						fTextL1[1]->AddText(Form("L1 JET TRIGGER = OK, ENJOY...")); 
					}
					else {
						fTextL1[1]->SetFillColor(2) ;
						fTextL1[1]->AddText(Form("HOT SPOT IN L1 JET TRIGGER = CALL EXPERT!!")); 
/*
						for(Int_t ix = 1; ix <=  hL1JetPatch->GetNbinsX(); ix++) {
							for(Int_t iy = 1; iy <=  hL1JetPatch->GetNbinsY(); iy++) {
								if(badL1J[ix-1][iy-1] != 0) printf("L1 Jet patch with position x = %d, y = %d is out of range\n",(4*ix-4),(4*iy-4));
							}
						}
*/

					}
				}//fTextL1[1]
			} // L1 Jet patch checking done
      } // if (specie != calibSpecieId) ..

			if(hFrameR->GetEntries() !=0) {
				lstF = hFrameR->GetListOfFunctions();
				CleanListOfFunctions(lstF);

				Int_t badLink[32] = {0};
				Int_t nBadLink = 0;
				for(Int_t ix = 1; ix <= hFrameR->GetNbinsX(); ix++) {
					Double_t binContent = hFrameR->GetBinContent(ix) ; 
					if (binContent == 0) {
						badLink[ix-1] += 1;
						nBadLink += 1;
					}
				}
				if(fTextL1[2]){
					lstF->Add(fTextL1[2]->Clone()) ;
					fTextL1[2]->Clear() ; 
	
				if (nBadLink == 0) {
						fTextL1[2]->SetFillColor(3) ;
						fTextL1[2]->AddText(Form("LINK TRU-STU = OK, ENJOY...")); 
					}
					else {
						fTextL1[2]->SetFillColor(2) ;
						fTextL1[2]->AddText(Form("PROBLEM WITH TRU-STU LINK = CALL EXPERT!!"));
/*
						for(Int_t ix = 0; ix <= hFrameR->GetNbinsX(); ix++) {
							if(badLink[ix] != 0) printf("STU link with TRU %d is out\n",ix);
						}
*/
					}   
				}//fTextL1[2]
			} // Checker for link TRU-STU done
    }

  } // specie
}
//______________________________________________________________________________

void AliEMCALQAChecker::Init(const AliQAv1::DETECTORINDEX_t det) 
{
	/// intialises QA and QA checker settings
	AliQAv1::Instance(det) ; 
	Float_t hiValue[AliQAv1::kNBIT] ; 
	Float_t lowValue[AliQAv1::kNBIT] ;
	lowValue[AliQAv1::kINFO]      = 0.0   ; 
	hiValue[AliQAv1::kINFO]       = 0.1 ; 
	lowValue[AliQAv1::kWARNING]   = 0.1 ; 
  hiValue[AliQAv1::kWARNING]    = 0.5 ; 
	lowValue[AliQAv1::kERROR]     = 0.5   ; 
	hiValue[AliQAv1::kERROR]      = 0.8 ; 
	lowValue[AliQAv1::kFATAL]     = 0.8   ; 
	hiValue[AliQAv1::kFATAL]      = 1.0 ; 
	SetHiLo(&hiValue[0], &lowValue[0]) ; 
}

//______________________________________________________________________________

void AliEMCALQAChecker::CleanListOfFunctions(TList *list)
{ // clean up

	if (list) {
		TObject *stats = list->FindObject("stats"); list->Remove(stats);
		TObject *obj;
		while ((obj = list->First())) { while(list->Remove(obj)) { } delete obj; }
			if (stats) list->Add(stats);
		}
	else {
		AliWarning(Form("Checker : empty list of data functions; returning"));
		return;
	}

}
Commit	Line	Data
94594e5d	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	Checks the quality assurance.
	18	By comparing with reference data
	19
	20	Based on PHOS code written by
	21	Y. Schutz CERN July 2007
9e47432c	22
a2655076	23	For the moment we only implement the checking of raw data QA.
a2655076	24	The checked for ESD and RecPoints will be implemented later.
9e47432c	25
9e47432c	26
9e47432c	27	*/
9e47432c	28
94594e5d	29
	30	// --- ROOT system ---
	31	#include <TClass.h>
9e47432c	32	#include <TH1.h>
9e47432c	33	#include <TF1.h>
94594e5d	34	#include <TH1I.h>
38986b78	35	#include <TH2F.h>
94594e5d	36	#include <TIterator.h>
	37	#include <TKey.h>
	38	#include <TFile.h>
9e47432c	39	#include <TLine.h>
38986b78	40	#include <TText.h>
9e47432c	41	#include <TPaveText.h>
9e47432c	42	#include <TMath.h>
94594e5d	43
	44	// --- Standard library ---
	45
	46	// --- AliRoot header files ---
	47	#include "AliLog.h"
4e25ac79	48	#include "AliQAv1.h"
94594e5d	49	#include "AliQAChecker.h"
	50	#include "AliEMCALQAChecker.h"
	51
	52	ClassImp(AliEMCALQAChecker)
	53
9e47432c	54	//__________________________________________________________________
	55	AliEMCALQAChecker::AliEMCALQAChecker() :
	56	AliQACheckerBase("EMCAL","EMCAL Quality Assurance Data Maker"),
afae9650	57	fTextSM(new TText*[fgknSM]),
8a38cd34	58	fLineCol(new TLine(47.5,-0.5,47.5,119.5)),
00957c37	59	fText(new TPaveText(0.2,0.7,0.8,0.9,"NDC"))
9e47432c	60	{
38986b78	61	// ctor
	62	fLineCol->SetLineColor(1);
	63	fLineCol->SetLineWidth(2);
38986b78	64
38986b78	65	fTextSM[0]= new TText(20, 12, "SM A0");
8a38cd34	66	fTextSM[1]= new TText(20, 36, "SM A1");
	67	fTextSM[2]= new TText(20, 60, "SM A2");
	68	fTextSM[3]= new TText(20, 84, "SM A3");
	69	fTextSM[4]= new TText(20, 108,"SM A4");
b8769ad2	70	fTextSM[5]= new TText(20, 132,"SM A5");
8a38cd34	71
b8769ad2	72	fTextSM[6]= new TText(64, 12, "SM C0");
	73	fTextSM[7]= new TText(64, 36, "SM C1");
	74	fTextSM[8]= new TText(64, 60, "SM C2");
	75	fTextSM[9]= new TText(64, 84, "SM C3");
	76	fTextSM[10]= new TText(64, 108,"SM C4");
	77	fTextSM[11]= new TText(64, 132,"SM C5");
8a38cd34	78
b8769ad2	79	for(int i = 0; i < 5; i++) {
8a38cd34	80	fLineRow[i] = new TLine(-0.5,23.5+(24i),95.5,23.5+(24i));
	81	fLineRow[i]->SetLineColor(1);
	82	fLineRow[i]->SetLineWidth(2);
	83	}
	84
a2e583d8	85	for(int i = 0; i < 3; i++) {
	86	fTextL1[i] = new TPaveText(0.2,0.7,0.8,0.9,"NDC");
	87	}
	88
8a38cd34	89
9e47432c	90	}
	91
	92	//__________________________________________________________________
	93	AliEMCALQAChecker::~AliEMCALQAChecker()
	94	{
	95	/// dtor
38986b78	96	delete [] fTextSM ;
a42ceb0e	97	delete fLineCol ;
b8769ad2	98	for (Int_t i=0; i<5; ++i) delete fLineRow[i] ;
a42ceb0e	99	delete fText ;
9e47432c	100	}
9e47432c	101
9e47432c	102	//______________________________________________________________________________
a42ceb0e	103	void AliEMCALQAChecker::Check(Double_t * test, AliQAv1::ALITASK_t index, TObjArray ** list, const AliDetectorRecoParam * /recoParam/)
9e47432c	104	{
	105	/// Check objects in list
	106
	107	if ( index == AliQAv1::kRAW )
	108	{
a42ceb0e	109	CheckRaws(test, list);
9e47432c	110	printf ("checkers for task %d \n", index) ;
	111	}
	112
	113	if ( index == AliQAv1::kREC)
	114	{
a42ceb0e	115	CheckRecPoints(test, list);
9e47432c	116	}
	117
	118	if ( index == AliQAv1::kESD )
	119	{
a42ceb0e	120	CheckESD(test, list);
9e47432c	121	}
9e47432c	122	AliWarning(Form("Checker for task %d not implement for the moment",index));
9e47432c	123	}
	124
	125	//______________________________________________________________________________
	126	TH1*
	127	AliEMCALQAChecker::GetHisto(TObjArray* list, const char* hname, Int_t specie) const
	128	{
	129	/// Get a given histo from the list
	130	TH1* h = static_cast<TH1*>(list->FindObject(Form("%s_%s",AliRecoParam::GetEventSpecieName(specie),hname)));
	131	if (!h)
	132	{
	133	AliError(Form("Did not find expected histo %s",hname));
	134	}
	135	return h;
	136	}
	137
	138	//______________________________________________________________________________
	139	Double_t
	140	AliEMCALQAChecker::MarkHisto(TH1& histo, Double_t value) const
	141	{
	142	/// Mark histo as originator of some QA error/warning
	143
	144	if ( value != 1.0 )
	145	{
	146	histo.SetBit(AliQAv1::GetQABit());
	147	}
	148
	149	return value;
	150	}
	151
	152
	153	//______________________________________________________________________________
a42ceb0e	154	void AliEMCALQAChecker::CheckRaws(Double_t * test, TObjArray ** list)
9e47432c	155	{
f05c8877	156	// Check RAW QA histograms
	157	// -- Yaxian Mao, CCNU/CERN/LPSC
	158	//adding new checking method: 25/04/2010, Yaxian Mao
	159	//Comparing the amplitude from current run to the reference run, if the ratio in the range [0.8, .12], count as a good tower.
	160	//If more than 90% towers are good, EMCAL works fine, otherwise experts should be contacted.
38986b78	161
38986b78	162	Int_t nTowersPerSM = 24*48; // number of towers in a SuperModule; 24x48
afae9650	163	Double_t nTot = fgknSM * nTowersPerSM ;
180c431b	164	TList *lstF = 0;
de96ebc9	165	Int_t calibSpecieId = (Int_t)TMath::Log2( AliRecoParam::kCalib );
a2655076	166	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
a42ceb0e	167	test[specie] = 0.0 ;
a2e583d8	168	if ( !AliQAv1::Instance()->IsEventSpecieSet(specie)) continue ;
a2e583d8	169	if (list[specie]->GetEntries() == 0) test[specie] = 0. ; // nothing to check
a2655076	170	else {
a2e583d8	171	//get calib histos
	172	TH2F * hdata = (TH2F*)list[specie]->At(k2DRatioAmp) ;
	173	TH1F * ratio = (TH1F*)list[specie]->At(kRatioDist) ;
	174
	175	//get L1 histos
	176	TH2F hL1GammaPatch = (TH2F)list[specie]->At(kGL1);
	177	TH2F hL1JetPatch = (TH2F)list[specie]->At(kJL1);
	178	TH1I hFrameR = (TH1I)list[specie]->At(kSTUTRU);
	179
	180	//calib histo checker first:
	181
	182	if(hdata->GetEntries()!=0 && ratio->GetEntries()!=0) {
	183	//adding the lines to distinguish different SMs
	184	lstF = hdata->GetListOfFunctions();
	185	CleanListOfFunctions(lstF);
	186	lstF->Add(fLineCol->Clone());
	187	for(Int_t iLine = 0; iLine < 4; iLine++) {
	188	lstF->Add(fLineRow[iLine]->Clone());
	189	}
	190	//Now adding the text to for each SM
	191	for(Int_t iSM = 0 ; iSM < fgknSM ; iSM++){ //number of SMs loop start
	192	lstF->Add(fTextSM[iSM]->Clone());
	193	}
	194	//
	195	lstF = ratio->GetListOfFunctions();
	196	CleanListOfFunctions(lstF);
	197	//
	198	//now check the ratio histogram
	199	Double_t binContent = 0. ;
edd592b8	200	Int_t nGoodTower = 0 ;
a2e583d8	201	Double_t rv = 0. ;
	202	for(Int_t ix = 1; ix <= hdata->GetNbinsX(); ix++) {
	203	for(Int_t iy = 1; iy <= hdata->GetNbinsY(); iy++) {
	204	binContent = hdata->GetBinContent(ix, iy) ;
edd592b8	205	if (binContent < 1.2 && binContent > 0.8) nGoodTower++ ;
a2e583d8	206	}
a2e583d8	207	}
edd592b8	208	rv = nGoodTower/nTot ;
a2e583d8	209	printf("%2.2f %% towers out of range [0.8, 1.2]\n", (1-rv)*100);
	210	if(fText){
	211	lstF->Add(fText->Clone()) ;
	212	fText->Clear() ;
7e1d9a9b	213
a2e583d8	214	fText->AddText(Form("%2.2f %% towers out of range [0.8, 1.2]", (1-rv)*100));
	215	if (rv < 0.9) {
	216	test[specie] = 0.9 ;
	217	// 2 lines text info for quality
	218	fText->SetFillColor(2) ;
	219	fText->AddText(Form("EMCAL = NOK, CALL EXPERTS!!!"));
	220	}
	221	else {
	222	test[specie] = 0.1 ;
	223	fText->SetFillColor(3) ;
	224	fText->AddText(Form("EMCAL = OK, ENJOY..."));
	225	}
	226	}//fText
	227	} // calib histo checking done
	228
	229	//now L1 checks:
de96ebc9	230	if (specie != calibSpecieId) {
de96ebc9	231	if(hL1GammaPatch->GetEntries() !=0 ) {
a2e583d8	232	lstF = hL1GammaPatch->GetListOfFunctions();
	233	CleanListOfFunctions(lstF);
	234
	235
	236	//Checker for L1GammaPatch (if a patch triggers > sigmaG * mean value (1/#patch positions total) says "hot spot !")
edd592b8	237	Double_t dL1GmeanTrig = 1/2961.;
a2e583d8	238	Int_t sigmaG = 5; // deviation from mean value
edd592b8	239	Double_t dL1GEntries = hL1GammaPatch->GetEntries();
	240	Int_t badL1G[48][64] = {{0}} ;
	241	Int_t nBadL1G = 0;
a2e583d8	242	for(Int_t ix = 1; ix <= hL1GammaPatch->GetNbinsX(); ix++) {
	243	for(Int_t iy = 1; iy <= hL1GammaPatch->GetNbinsY(); iy++) {
	244	Double_t binContent = hL1GammaPatch->GetBinContent(ix, iy) ;
	245	if (binContent != 0) {
edd592b8	246	if ((double)binContent/(double)dL1GEntries > sigmaG*dL1GmeanTrig) {
	247	badL1G[ix-1][iy-1] += 1;
	248	nBadL1G += 1;
a2e583d8	249	}
	250	}
	251	}
	252	}
	253
	254	if(fTextL1[0]){
	255	lstF->Add(fTextL1[0]->Clone()) ;
	256	fTextL1[0]->Clear() ;
	257
edd592b8	258	if (nBadL1G == 0) {
a2e583d8	259	fTextL1[0]->SetFillColor(3) ;
	260	fTextL1[0]->AddText(Form("L1 GAMMA TRIGGER = OK, ENJOY..."));
	261	}
	262	else {
	263	fTextL1[0]->SetFillColor(2) ;
	264	fTextL1[0]->AddText(Form("HOT SPOT IN L1 GAMMA TRIGGER = CALL EXPERT!!"));
	265	/*
	266	for(Int_t ix = 1; ix <= hL1GammaPatch->GetNbinsX(); ix++) {
	267	for(Int_t iy = 1; iy <= hL1GammaPatch->GetNbinsY(); iy++) {
edd592b8	268	if(badL1G[ix-1][iy-1] != 0) printf("L1 Gamma patch with position x = %d, y = %d is out of range\n",ix,iy);
a2e583d8	269	}
	270	}
	271	*/
	272	}
	273	}//fTextL1[0]
	274	}// L1 gamma patch checking done
	275
	276	if(hL1JetPatch->GetEntries() !=0) {
	277	lstF = hL1JetPatch->GetListOfFunctions();
	278	CleanListOfFunctions(lstF);
	279
	280	//Checker for L1JetPatch (if a patch triggers > sigmaJ * mean value (1/#patch positions total) says "hot spot !")
edd592b8	281	Double_t dL1JmeanTrig = 1/126.;
a2e583d8	282	Int_t sigmaJ = 5; // deviation from mean value
edd592b8	283	Double_t dL1JEntries = hL1JetPatch->GetEntries();
	284	Int_t badL1J[12][16] = {{0}} ;
	285	Int_t nBadL1J = 0;
a2e583d8	286	for(Int_t ix = 1; ix <= hL1JetPatch->GetNbinsX(); ix++) {
	287	for(Int_t iy = 1; iy <= hL1JetPatch->GetNbinsY(); iy++) {
	288	Double_t binContent = hL1JetPatch->GetBinContent(ix, iy) ;
	289	if (binContent != 0) {
edd592b8	290	if ((double)binContent/(double)dL1JEntries > sigmaJ*dL1JmeanTrig) {
	291	badL1J[ix-1][iy-1] += 1 ;
	292	nBadL1J += 1;
a2e583d8	293	}
	294	}
	295	}
	296	}
	297
	298	if(fTextL1[1]){
	299	lstF->Add(fTextL1[1]->Clone()) ;
	300	fTextL1[1]->Clear() ;
	301
edd592b8	302	if (nBadL1J == 0) {
a2e583d8	303	fTextL1[1]->SetFillColor(3) ;
	304	fTextL1[1]->AddText(Form("L1 JET TRIGGER = OK, ENJOY..."));
	305	}
	306	else {
	307	fTextL1[1]->SetFillColor(2) ;
	308	fTextL1[1]->AddText(Form("HOT SPOT IN L1 JET TRIGGER = CALL EXPERT!!"));
	309	/*
	310	for(Int_t ix = 1; ix <= hL1JetPatch->GetNbinsX(); ix++) {
	311	for(Int_t iy = 1; iy <= hL1JetPatch->GetNbinsY(); iy++) {
edd592b8	312	if(badL1J[ix-1][iy-1] != 0) printf("L1 Jet patch with position x = %d, y = %d is out of range\n",(4ix-4),(4iy-4));
a2e583d8	313	}
	314	}
	315	*/
	316
	317	}
	318	}//fTextL1[1]
	319	} // L1 Jet patch checking done
de96ebc9	320	} // if (specie != calibSpecieId) ..
a2e583d8	321
	322	if(hFrameR->GetEntries() !=0) {
	323	lstF = hFrameR->GetListOfFunctions();
	324	CleanListOfFunctions(lstF);
	325
edd592b8	326	Int_t badLink[32] = {0};
edd592b8	327	Int_t nBadLink = 0;
bb5d026f	328	for(Int_t ix = 1; ix <= hFrameR->GetNbinsX(); ix++) {
a2e583d8	329	Double_t binContent = hFrameR->GetBinContent(ix) ;
a2e583d8	330	if (binContent == 0) {
bb5d026f	331	badLink[ix-1] += 1;
edd592b8	332	nBadLink += 1;
a2e583d8	333	}
	334	}
	335	if(fTextL1[2]){
	336	lstF->Add(fTextL1[2]->Clone()) ;
	337	fTextL1[2]->Clear() ;
	338
edd592b8	339	if (nBadLink == 0) {
a2e583d8	340	fTextL1[2]->SetFillColor(3) ;
	341	fTextL1[2]->AddText(Form("LINK TRU-STU = OK, ENJOY..."));
	342	}
	343	else {
	344	fTextL1[2]->SetFillColor(2) ;
	345	fTextL1[2]->AddText(Form("PROBLEM WITH TRU-STU LINK = CALL EXPERT!!"));
	346	/*
	347	for(Int_t ix = 0; ix <= hFrameR->GetNbinsX(); ix++) {
edd592b8	348	if(badLink[ix] != 0) printf("STU link with TRU %d is out\n",ix);
a2e583d8	349	}
	350	*/
	351	}
	352	}//fTextL1[2]
	353	} // Checker for link TRU-STU done
de96ebc9	354	}
9e47432c	355
de96ebc9	356	} // specie
a2e583d8	357	}
9e47432c	358	//______________________________________________________________________________
a2e583d8	359
9e47432c	360	void AliEMCALQAChecker::Init(const AliQAv1::DETECTORINDEX_t det)
	361	{
	362	/// intialises QA and QA checker settings
	363	AliQAv1::Instance(det) ;
	364	Float_t hiValue[AliQAv1::kNBIT] ;
	365	Float_t lowValue[AliQAv1::kNBIT] ;
	366	lowValue[AliQAv1::kINFO] = 0.0 ;
	367	hiValue[AliQAv1::kINFO] = 0.1 ;
9e47432c	368	lowValue[AliQAv1::kWARNING] = 0.1 ;
6a754398	369	hiValue[AliQAv1::kWARNING] = 0.5 ;
9e47432c	370	lowValue[AliQAv1::kERROR] = 0.5 ;
	371	hiValue[AliQAv1::kERROR] = 0.8 ;
	372	lowValue[AliQAv1::kFATAL] = 0.8 ;
	373	hiValue[AliQAv1::kFATAL] = 1.0 ;
	374	SetHiLo(&hiValue[0], &lowValue[0]) ;
	375	}
94594e5d	376
a2e583d8	377	//______________________________________________________________________________
	378
	379	void AliEMCALQAChecker::CleanListOfFunctions(TList *list)
edd592b8	380	{ // clean up
a2e583d8	381
	382	if (list) {
	383	TObject *stats = list->FindObject("stats"); list->Remove(stats);
	384	TObject *obj;
	385	while ((obj = list->First())) { while(list->Remove(obj)) { } delete obj; }
	386	if (stats) list->Add(stats);
	387	}
	388	else {
	389	AliWarning(Form("Checker : empty list of data functions; returning"));
	390	return;
	391	}
	392
	393	}
	394
	395