[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 "AliCDBManager.h"
#include "AliCDBEntry.h"
#include "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliQAThresholds.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.8,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. 


  // Retrieve the thresholds
  Float_t ratioThresh = 0.9;   // threshold for calibration ratio = good towers/all towers (default 0.9)
  Float_t ThreshG     = 0.5;   // threshold for L1 Gamma triggers (default 0.5)
  Float_t ThreshJ     = 0.5;   // threshold for L1 Jet triggers (default 0.5)
  Int_t badLinkThresh = 1;     // threshold for bad links (default 1)

  AliCDBManager* man = AliCDBManager::Instance();
  if(man){
    AliCDBEntry* entry = man->Get("GRP/Calib/QAThresholds");
    if(entry){
      TObjArray* branch = (TObjArray*) entry->GetObject();
      if(branch){
	AliQAThresholds* thresholds = (AliQAThresholds*) branch->FindObject("EMC");
	if(thresholds){
	  TParameter<float>* ParamR  = (TParameter<float>*) thresholds->GetThreshold(0);
	  TParameter<float>* ParamG  = (TParameter<float>*) thresholds->GetThreshold(1);
	  TParameter<float>* ParamJ  = (TParameter<float>*) thresholds->GetThreshold(2);
	  TParameter<int>* ParamL  = (TParameter<int>*) thresholds->GetThreshold(3);
	  if(ParamR)
	    ratioThresh = ParamR->GetVal();
	  if(ParamG)
	    ThreshG = ParamG->GetVal();
	  if(ParamJ)
	    ThreshJ = ParamJ->GetVal();
	  if(ParamL)
	    badLinkThresh = ParamL->GetVal();
	}
      }
    }
  }
  
  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:

			// first clean lines, text (functions)
			lstF = hdata->GetListOfFunctions();
			CleanListOfFunctions(lstF);
			lstF = ratio->GetListOfFunctions();
			CleanListOfFunctions(lstF);

			if(hdata->GetEntries()!=0 && ratio->GetEntries()!=0) {

			  lstF = hdata->GetListOfFunctions();

				//adding the lines to distinguish different SMs
				lstF->Add(fLineCol->Clone()); 
				for(Int_t iLine = 0; iLine < 5; 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()); 
				}			
				

				//now check the ratio histogram
				lstF = ratio->GetListOfFunctions();

				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 < ratioThresh) {
						test[specie] = ratioThresh;
						// 2 lines text info for quality         
						fText->SetFillColor(2) ;
						fText->AddText(Form("EMCAL = NOK, CALL EXPERTS!!!")); 
					}
					else {
						test[specie] = 1 - ratioThresh;
						fText->SetFillColor(3) ;
						fText->AddText(Form("EMCAL = OK, ENJOY...")); 
					}
				}//fText
			} // calib histo checking done

			// ========================================================================================
			// now L1 checks:

			// first clean lines, text (functions)
			lstF = hL1GammaPatch->GetListOfFunctions();
			CleanListOfFunctions(lstF);
			lstF = hL1JetPatch->GetListOfFunctions();
			CleanListOfFunctions(lstF);
			lstF = hFrameR->GetListOfFunctions();
			CleanListOfFunctions(lstF);

			if (specie != calibSpecieId) {
			  //if(hL1GammaPatch->GetEntries() !=0 ) {
			  if(hL1GammaPatch->GetEntries() > 10) { // need some statistics for hot spot calculation
 			        lstF = hL1GammaPatch->GetListOfFunctions();

				// Checker for L1GammaPatch 
				//Double_t dL1GmeanTrig    = 1./2961.; 
				//Double_t dL1GmeanTrigTRU = 1./32.; 
				//Int_t sigmaG    = 100; // deviation from mean value (increased to 100)
				//Int_t sigmaGTRU = 5; // deviation from mean value for TRUs
				Double_t dL1GEntries = hL1GammaPatch->GetEntries();
				Int_t badL1G[48][64]   = {{0}} ;
				Int_t badL1GTRU[2][16] = {{0}} ;
				Int_t nBadL1G    = 0;
				Int_t nBadL1GTRU = 0;
				Double_t binContentTRU[2][16] = {{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) {
				      
				      // fill counter for TRUs
				      binContentTRU[(Int_t)((ix-1)/24)][(Int_t)((iy-1)/4)] += binContent;
				      
				      // OLD METHOD (if a patch triggers > sigmaG * mean value (1/#patch positions total) says "hot spot !")
				      // if ((double)binContent/(double)dL1GEntries > sigmaG*dL1GmeanTrig) {
				      // 	badL1G[ix-1][iy-1] += 1;
				      // 	nBadL1G += 1;
				      // }

				      // NEW METHOD (if Rate > Threshold * ( (Number of towers or TRUs * Average rate) - Rate ) --> "hot spot !")
				      // Thresold = how much does the noisy tower/TRU contribute to the rate
				      //            1.0 --> Rate of noisy tower/TRU = Rate of all other towers/TRUs  
				      if (binContent/dL1GEntries > ThreshG / ( 1 + ThreshG )) {
					badL1G[ix-1][iy-1] += 1;
					nBadL1G += 1;
				      }
				    }
				  }
				}

				// check TRUs
				for(Int_t ix = 1; ix <=  2; ix++) {
				  for(Int_t iy = 1; iy <=  16; iy++) {
				    if(binContentTRU[ix-1][iy-1]/dL1GEntries >  ThreshG / ( 1 + ThreshG )) {
				      badL1GTRU[ix-1][iy-1] += 1;
				      nBadL1GTRU += 1;
				    }
				  }
				}
				
				if(fTextL1[0]){
					lstF->Add(fTextL1[0]->Clone()) ;
					fTextL1[0]->Clear() ; 

					if (nBadL1G == 0 && nBadL1GTRU == 0 ) {
						fTextL1[0]->SetFillColor(3) ;
						fTextL1[0]->AddText(Form("L1 GAMMA TRIGGER = OK, ENJOY...")); 
					}
					else if (nBadL1G == 0){
						fTextL1[0]->SetFillColor(2) ;
						fTextL1[0]->AddText(Form("HOT SPOT IN L1 GAMMA TRIGGER (TRU) = CALL EXPERT!!"));
						
					}
					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) {
			if(hL1JetPatch->GetEntries() > 10) { // need some statistics for hot spot calculation

			  lstF = hL1JetPatch->GetListOfFunctions();

				// Checker for L1JetPatch
				//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) {
				      
				      // OLD METHOD  (if a patch triggers > sigmaJ * mean value (1/#patch positions total) says "hot spot !")
				      // if ((double)binContent/(double)dL1JEntries > sigmaJ*dL1JmeanTrig) {
				      // 	badL1J[ix-1][iy-1] += 1 ;
				      // 	nBadL1J += 1;
				      // }

				      // NEW METHOD (if Rate > Threshold * ( (Number of towers or TRUs * Average rate) - Rate ) --> "hot spot !")
				      // Threshold: same definitionas for Gamma
				       if ((double)binContent/(double)dL1JEntries > ThreshJ / ( 1 + ThreshJ )) {
				       	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();
			
				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 < badLinkThresh) {
						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"
a57708c8	48	#include "AliCDBManager.h"
a57708c8	49	#include "AliCDBEntry.h"
4e25ac79	50	#include "AliQAv1.h"
94594e5d	51	#include "AliQAChecker.h"
a57708c8	52	#include "AliQAThresholds.h"
94594e5d	53	#include "AliEMCALQAChecker.h"
	54
	55	ClassImp(AliEMCALQAChecker)
	56
9e47432c	57	//__________________________________________________________________
	58	AliEMCALQAChecker::AliEMCALQAChecker() :
	59	AliQACheckerBase("EMCAL","EMCAL Quality Assurance Data Maker"),
afae9650	60	fTextSM(new TText*[fgknSM]),
8a38cd34	61	fLineCol(new TLine(47.5,-0.5,47.5,119.5)),
00957c37	62	fText(new TPaveText(0.2,0.7,0.8,0.9,"NDC"))
9e47432c	63	{
38986b78	64	// ctor
	65	fLineCol->SetLineColor(1);
	66	fLineCol->SetLineWidth(2);
38986b78	67
38986b78	68	fTextSM[0]= new TText(20, 12, "SM A0");
8a38cd34	69	fTextSM[1]= new TText(20, 36, "SM A1");
	70	fTextSM[2]= new TText(20, 60, "SM A2");
	71	fTextSM[3]= new TText(20, 84, "SM A3");
	72	fTextSM[4]= new TText(20, 108,"SM A4");
b8769ad2	73	fTextSM[5]= new TText(20, 132,"SM A5");
8a38cd34	74
b8769ad2	75	fTextSM[6]= new TText(64, 12, "SM C0");
	76	fTextSM[7]= new TText(64, 36, "SM C1");
	77	fTextSM[8]= new TText(64, 60, "SM C2");
	78	fTextSM[9]= new TText(64, 84, "SM C3");
	79	fTextSM[10]= new TText(64, 108,"SM C4");
	80	fTextSM[11]= new TText(64, 132,"SM C5");
8a38cd34	81
b8769ad2	82	for(int i = 0; i < 5; i++) {
8a38cd34	83	fLineRow[i] = new TLine(-0.5,23.5+(24i),95.5,23.5+(24i));
	84	fLineRow[i]->SetLineColor(1);
	85	fLineRow[i]->SetLineWidth(2);
	86	}
	87
a2e583d8	88	for(int i = 0; i < 3; i++) {
a57708c8	89	fTextL1[i] = new TPaveText(0.2,0.8,0.8,0.9,"NDC");
a2e583d8	90	}
a2e583d8	91
8a38cd34	92
9e47432c	93	}
	94
	95	//__________________________________________________________________
	96	AliEMCALQAChecker::~AliEMCALQAChecker()
	97	{
	98	/// dtor
38986b78	99	delete [] fTextSM ;
a42ceb0e	100	delete fLineCol ;
b8769ad2	101	for (Int_t i=0; i<5; ++i) delete fLineRow[i] ;
a42ceb0e	102	delete fText ;
9e47432c	103	}
9e47432c	104
9e47432c	105	//______________________________________________________________________________
a42ceb0e	106	void AliEMCALQAChecker::Check(Double_t * test, AliQAv1::ALITASK_t index, TObjArray ** list, const AliDetectorRecoParam * /recoParam/)
9e47432c	107	{
	108	/// Check objects in list
	109
	110	if ( index == AliQAv1::kRAW )
	111	{
a42ceb0e	112	CheckRaws(test, list);
b4776d2d	113	//printf ("checkers for task %d \n", index) ;
9e47432c	114	}
	115
	116	if ( index == AliQAv1::kREC)
	117	{
a42ceb0e	118	CheckRecPoints(test, list);
9e47432c	119	}
	120
	121	if ( index == AliQAv1::kESD )
	122	{
a42ceb0e	123	CheckESD(test, list);
9e47432c	124	}
b4776d2d	125	//AliWarning(Form("Checker for task %d not implement for the moment",index));
9e47432c	126	}
	127
	128	//______________________________________________________________________________
	129	TH1*
	130	AliEMCALQAChecker::GetHisto(TObjArray* list, const char* hname, Int_t specie) const
	131	{
	132	/// Get a given histo from the list
	133	TH1* h = static_cast<TH1*>(list->FindObject(Form("%s_%s",AliRecoParam::GetEventSpecieName(specie),hname)));
	134	if (!h)
	135	{
	136	AliError(Form("Did not find expected histo %s",hname));
	137	}
	138	return h;
	139	}
	140
	141	//______________________________________________________________________________
	142	Double_t
	143	AliEMCALQAChecker::MarkHisto(TH1& histo, Double_t value) const
	144	{
	145	/// Mark histo as originator of some QA error/warning
	146
	147	if ( value != 1.0 )
	148	{
	149	histo.SetBit(AliQAv1::GetQABit());
	150	}
	151
	152	return value;
	153	}
	154
	155
	156	//______________________________________________________________________________
a42ceb0e	157	void AliEMCALQAChecker::CheckRaws(Double_t * test, TObjArray ** list)
9e47432c	158	{
f05c8877	159	// Check RAW QA histograms
	160	// -- Yaxian Mao, CCNU/CERN/LPSC
	161	//adding new checking method: 25/04/2010, Yaxian Mao
	162	//Comparing the amplitude from current run to the reference run, if the ratio in the range [0.8, .12], count as a good tower.
	163	//If more than 90% towers are good, EMCAL works fine, otherwise experts should be contacted.
a57708c8	164
	165
	166	// Retrieve the thresholds
	167	Float_t ratioThresh = 0.9; // threshold for calibration ratio = good towers/all towers (default 0.9)
	168	Float_t ThreshG = 0.5; // threshold for L1 Gamma triggers (default 0.5)
	169	Float_t ThreshJ = 0.5; // threshold for L1 Jet triggers (default 0.5)
	170	Int_t badLinkThresh = 1; // threshold for bad links (default 1)
	171
	172	AliCDBManager* man = AliCDBManager::Instance();
	173	if(man){
	174	AliCDBEntry* entry = man->Get("GRP/Calib/QAThresholds");
	175	if(entry){
	176	TObjArray* branch = (TObjArray*) entry->GetObject();
	177	if(branch){
	178	AliQAThresholds* thresholds = (AliQAThresholds*) branch->FindObject("EMC");
	179	if(thresholds){
	180	TParameter<float>* ParamR = (TParameter<float>*) thresholds->GetThreshold(0);
	181	TParameter<float>* ParamG = (TParameter<float>*) thresholds->GetThreshold(1);
	182	TParameter<float>* ParamJ = (TParameter<float>*) thresholds->GetThreshold(2);
	183	TParameter<int>* ParamL = (TParameter<int>*) thresholds->GetThreshold(3);
	184	if(ParamR)
	185	ratioThresh = ParamR->GetVal();
	186	if(ParamG)
	187	ThreshG = ParamG->GetVal();
	188	if(ParamJ)
	189	ThreshJ = ParamJ->GetVal();
	190	if(ParamL)
	191	badLinkThresh = ParamL->GetVal();
	192	}
	193	}
	194	}
	195	}
	196
38986b78	197	Int_t nTowersPerSM = 24*48; // number of towers in a SuperModule; 24x48
afae9650	198	Double_t nTot = fgknSM * nTowersPerSM ;
180c431b	199	TList *lstF = 0;
de96ebc9	200	Int_t calibSpecieId = (Int_t)TMath::Log2( AliRecoParam::kCalib );
a2655076	201	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
a42ceb0e	202	test[specie] = 0.0 ;
a2e583d8	203	if ( !AliQAv1::Instance()->IsEventSpecieSet(specie)) continue ;
a2e583d8	204	if (list[specie]->GetEntries() == 0) test[specie] = 0. ; // nothing to check
a2655076	205	else {
a2e583d8	206	//get calib histos
	207	TH2F * hdata = (TH2F*)list[specie]->At(k2DRatioAmp) ;
	208	TH1F * ratio = (TH1F*)list[specie]->At(kRatioDist) ;
	209
	210	//get L1 histos
	211	TH2F hL1GammaPatch = (TH2F)list[specie]->At(kGL1);
	212	TH2F hL1JetPatch = (TH2F)list[specie]->At(kJL1);
	213	TH1I hFrameR = (TH1I)list[specie]->At(kSTUTRU);
	214
b4776d2d	215	// ========================================================================================
a2e583d8	216	//calib histo checker first:
a2e583d8	217
b4776d2d	218	// first clean lines, text (functions)
	219	lstF = hdata->GetListOfFunctions();
	220	CleanListOfFunctions(lstF);
	221	lstF = ratio->GetListOfFunctions();
	222	CleanListOfFunctions(lstF);
	223
	224	if(hdata->GetEntries()!=0 && ratio->GetEntries()!=0) {
	225
	226	lstF = hdata->GetListOfFunctions();
	227
a2e583d8	228	//adding the lines to distinguish different SMs
a2e583d8	229	lstF->Add(fLineCol->Clone());
b4776d2d	230	for(Int_t iLine = 0; iLine < 5; iLine++) {
a2e583d8	231	lstF->Add(fLineRow[iLine]->Clone());
	232	}
	233	//Now adding the text to for each SM
	234	for(Int_t iSM = 0 ; iSM < fgknSM ; iSM++){ //number of SMs loop start
	235	lstF->Add(fTextSM[iSM]->Clone());
b4776d2d	236	}
	237
	238
a2e583d8	239	//now check the ratio histogram
b4776d2d	240	lstF = ratio->GetListOfFunctions();
b4776d2d	241
a2e583d8	242	Double_t binContent = 0. ;
edd592b8	243	Int_t nGoodTower = 0 ;
a2e583d8	244	Double_t rv = 0. ;
	245	for(Int_t ix = 1; ix <= hdata->GetNbinsX(); ix++) {
	246	for(Int_t iy = 1; iy <= hdata->GetNbinsY(); iy++) {
	247	binContent = hdata->GetBinContent(ix, iy) ;
edd592b8	248	if (binContent < 1.2 && binContent > 0.8) nGoodTower++ ;
a2e583d8	249	}
a2e583d8	250	}
edd592b8	251	rv = nGoodTower/nTot ;
b4776d2d	252	//printf("%2.2f %% towers out of range [0.8, 1.2]\n", (1-rv)*100);
a2e583d8	253	if(fText){
	254	lstF->Add(fText->Clone()) ;
	255	fText->Clear() ;
7e1d9a9b	256
a2e583d8	257	fText->AddText(Form("%2.2f %% towers out of range [0.8, 1.2]", (1-rv)*100));
a57708c8	258	if (rv < ratioThresh) {
a57708c8	259	test[specie] = ratioThresh;
a2e583d8	260	// 2 lines text info for quality
	261	fText->SetFillColor(2) ;
	262	fText->AddText(Form("EMCAL = NOK, CALL EXPERTS!!!"));
	263	}
	264	else {
a57708c8	265	test[specie] = 1 - ratioThresh;
a2e583d8	266	fText->SetFillColor(3) ;
	267	fText->AddText(Form("EMCAL = OK, ENJOY..."));
	268	}
	269	}//fText
	270	} // calib histo checking done
	271
b4776d2d	272	// ========================================================================================
	273	// now L1 checks:
	274
	275	// first clean lines, text (functions)
	276	lstF = hL1GammaPatch->GetListOfFunctions();
	277	CleanListOfFunctions(lstF);
	278	lstF = hL1JetPatch->GetListOfFunctions();
	279	CleanListOfFunctions(lstF);
	280	lstF = hFrameR->GetListOfFunctions();
	281	CleanListOfFunctions(lstF);
a2e583d8	282
b4776d2d	283	if (specie != calibSpecieId) {
	284	//if(hL1GammaPatch->GetEntries() !=0 ) {
	285	if(hL1GammaPatch->GetEntries() > 10) { // need some statistics for hot spot calculation
	286	lstF = hL1GammaPatch->GetListOfFunctions();
a2e583d8	287
a57708c8	288	// Checker for L1GammaPatch
	289	//Double_t dL1GmeanTrig = 1./2961.;
	290	//Double_t dL1GmeanTrigTRU = 1./32.;
	291	//Int_t sigmaG = 100; // deviation from mean value (increased to 100)
	292	//Int_t sigmaGTRU = 5; // deviation from mean value for TRUs
edd592b8	293	Double_t dL1GEntries = hL1GammaPatch->GetEntries();
a57708c8	294	Int_t badL1G[48][64] = {{0}} ;
	295	Int_t badL1GTRU[2][16] = {{0}} ;
	296	Int_t nBadL1G = 0;
	297	Int_t nBadL1GTRU = 0;
	298	Double_t binContentTRU[2][16] = {{0.}};
a2e583d8	299	for(Int_t ix = 1; ix <= hL1GammaPatch->GetNbinsX(); ix++) {
a57708c8	300	for(Int_t iy = 1; iy <= hL1GammaPatch->GetNbinsY(); iy++) {
	301	Double_t binContent = hL1GammaPatch->GetBinContent(ix, iy) ;
	302	if (binContent != 0) {
	303
	304	// fill counter for TRUs
	305	binContentTRU[(Int_t)((ix-1)/24)][(Int_t)((iy-1)/4)] += binContent;
	306
	307	// OLD METHOD (if a patch triggers > sigmaG * mean value (1/#patch positions total) says "hot spot !")
	308	// if ((double)binContent/(double)dL1GEntries > sigmaG*dL1GmeanTrig) {
	309	// badL1G[ix-1][iy-1] += 1;
	310	// nBadL1G += 1;
	311	// }
	312
	313	// NEW METHOD (if Rate > Threshold * ( (Number of towers or TRUs * Average rate) - Rate ) --> "hot spot !")
	314	// Thresold = how much does the noisy tower/TRU contribute to the rate
	315	// 1.0 --> Rate of noisy tower/TRU = Rate of all other towers/TRUs
	316	if (binContent/dL1GEntries > ThreshG / ( 1 + ThreshG )) {
	317	badL1G[ix-1][iy-1] += 1;
	318	nBadL1G += 1;
	319	}
	320	}
	321	}
a2e583d8	322	}
a2e583d8	323
a57708c8	324	// check TRUs
	325	for(Int_t ix = 1; ix <= 2; ix++) {
	326	for(Int_t iy = 1; iy <= 16; iy++) {
	327	if(binContentTRU[ix-1][iy-1]/dL1GEntries > ThreshG / ( 1 + ThreshG )) {
	328	badL1GTRU[ix-1][iy-1] += 1;
	329	nBadL1GTRU += 1;
	330	}
	331	}
	332	}
	333
a2e583d8	334	if(fTextL1[0]){
	335	lstF->Add(fTextL1[0]->Clone()) ;
	336	fTextL1[0]->Clear() ;
	337
a57708c8	338	if (nBadL1G == 0 && nBadL1GTRU == 0 ) {
a2e583d8	339	fTextL1[0]->SetFillColor(3) ;
	340	fTextL1[0]->AddText(Form("L1 GAMMA TRIGGER = OK, ENJOY..."));
	341	}
a57708c8	342	else if (nBadL1G == 0){
a2e583d8	343	fTextL1[0]->SetFillColor(2) ;
a57708c8	344	fTextL1[0]->AddText(Form("HOT SPOT IN L1 GAMMA TRIGGER (TRU) = CALL EXPERT!!"));
	345
	346	}
	347	else{
	348	fTextL1[0]->SetFillColor(2) ;
	349	fTextL1[0]->AddText(Form("HOT SPOT IN L1 GAMMA TRIGGER = CALL EXPERT!!"));
	350	/*
	351	for(Int_t ix = 1; ix <= hL1GammaPatch->GetNbinsX(); ix++) {
	352	for(Int_t iy = 1; iy <= hL1GammaPatch->GetNbinsY(); iy++) {
edd592b8	353	if(badL1G[ix-1][iy-1] != 0) printf("L1 Gamma patch with position x = %d, y = %d is out of range\n",ix,iy);
a57708c8	354	}
	355	}
	356	*/
a2e583d8	357	}
	358	}//fTextL1[0]
	359	}// L1 gamma patch checking done
	360
b4776d2d	361	//if(hL1JetPatch->GetEntries() !=0) {
	362	if(hL1JetPatch->GetEntries() > 10) { // need some statistics for hot spot calculation
	363
	364	lstF = hL1JetPatch->GetListOfFunctions();
	365
a57708c8	366	// Checker for L1JetPatch
	367	//Double_t dL1JmeanTrig = 1/126.;
	368	//Int_t sigmaJ = 5; // deviation from mean value
edd592b8	369	Double_t dL1JEntries = hL1JetPatch->GetEntries();
	370	Int_t badL1J[12][16] = {{0}} ;
	371	Int_t nBadL1J = 0;
a2e583d8	372	for(Int_t ix = 1; ix <= hL1JetPatch->GetNbinsX(); ix++) {
a57708c8	373	for(Int_t iy = 1; iy <= hL1JetPatch->GetNbinsY(); iy++) {
	374	Double_t binContent = hL1JetPatch->GetBinContent(ix, iy) ;
	375	if (binContent != 0) {
	376
	377	// OLD METHOD (if a patch triggers > sigmaJ * mean value (1/#patch positions total) says "hot spot !")
	378	// if ((double)binContent/(double)dL1JEntries > sigmaJ*dL1JmeanTrig) {
	379	// badL1J[ix-1][iy-1] += 1 ;
	380	// nBadL1J += 1;
	381	// }
	382
	383	// NEW METHOD (if Rate > Threshold * ( (Number of towers or TRUs * Average rate) - Rate ) --> "hot spot !")
	384	// Threshold: same definitionas for Gamma
	385	if ((double)binContent/(double)dL1JEntries > ThreshJ / ( 1 + ThreshJ )) {
	386	badL1J[ix-1][iy-1] += 1 ;
	387	nBadL1J += 1;
	388	}
	389	}
	390	}
a2e583d8	391	}
a57708c8	392
a2e583d8	393	if(fTextL1[1]){
	394	lstF->Add(fTextL1[1]->Clone()) ;
	395	fTextL1[1]->Clear() ;
	396
edd592b8	397	if (nBadL1J == 0) {
a2e583d8	398	fTextL1[1]->SetFillColor(3) ;
	399	fTextL1[1]->AddText(Form("L1 JET TRIGGER = OK, ENJOY..."));
	400	}
	401	else {
	402	fTextL1[1]->SetFillColor(2) ;
	403	fTextL1[1]->AddText(Form("HOT SPOT IN L1 JET TRIGGER = CALL EXPERT!!"));
	404	/*
	405	for(Int_t ix = 1; ix <= hL1JetPatch->GetNbinsX(); ix++) {
	406	for(Int_t iy = 1; iy <= hL1JetPatch->GetNbinsY(); iy++) {
edd592b8	407	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	408	}
	409	}
	410	*/
	411
	412	}
	413	}//fTextL1[1]
	414	} // L1 Jet patch checking done
de96ebc9	415	} // if (specie != calibSpecieId) ..
a2e583d8	416
a2e583d8	417	if(hFrameR->GetEntries() !=0) {
b4776d2d	418	lstF = hFrameR->GetListOfFunctions();
b4776d2d	419
edd592b8	420	Int_t badLink[32] = {0};
edd592b8	421	Int_t nBadLink = 0;
bb5d026f	422	for(Int_t ix = 1; ix <= hFrameR->GetNbinsX(); ix++) {
a2e583d8	423	Double_t binContent = hFrameR->GetBinContent(ix) ;
a2e583d8	424	if (binContent == 0) {
bb5d026f	425	badLink[ix-1] += 1;
edd592b8	426	nBadLink += 1;
a2e583d8	427	}
	428	}
	429	if(fTextL1[2]){
	430	lstF->Add(fTextL1[2]->Clone()) ;
	431	fTextL1[2]->Clear() ;
	432
a57708c8	433	if (nBadLink < badLinkThresh) {
a2e583d8	434	fTextL1[2]->SetFillColor(3) ;
	435	fTextL1[2]->AddText(Form("LINK TRU-STU = OK, ENJOY..."));
	436	}
	437	else {
	438	fTextL1[2]->SetFillColor(2) ;
	439	fTextL1[2]->AddText(Form("PROBLEM WITH TRU-STU LINK = CALL EXPERT!!"));
	440	/*
	441	for(Int_t ix = 0; ix <= hFrameR->GetNbinsX(); ix++) {
edd592b8	442	if(badLink[ix] != 0) printf("STU link with TRU %d is out\n",ix);
a2e583d8	443	}
	444	*/
	445	}
	446	}//fTextL1[2]
	447	} // Checker for link TRU-STU done
de96ebc9	448	}
9e47432c	449
de96ebc9	450	} // specie
a2e583d8	451	}
9e47432c	452	//______________________________________________________________________________
a2e583d8	453
9e47432c	454	void AliEMCALQAChecker::Init(const AliQAv1::DETECTORINDEX_t det)
	455	{
	456	/// intialises QA and QA checker settings
	457	AliQAv1::Instance(det) ;
	458	Float_t hiValue[AliQAv1::kNBIT] ;
	459	Float_t lowValue[AliQAv1::kNBIT] ;
	460	lowValue[AliQAv1::kINFO] = 0.0 ;
	461	hiValue[AliQAv1::kINFO] = 0.1 ;
9e47432c	462	lowValue[AliQAv1::kWARNING] = 0.1 ;
6a754398	463	hiValue[AliQAv1::kWARNING] = 0.5 ;
9e47432c	464	lowValue[AliQAv1::kERROR] = 0.5 ;
	465	hiValue[AliQAv1::kERROR] = 0.8 ;
	466	lowValue[AliQAv1::kFATAL] = 0.8 ;
	467	hiValue[AliQAv1::kFATAL] = 1.0 ;
	468	SetHiLo(&hiValue[0], &lowValue[0]) ;
	469	}
94594e5d	470
a2e583d8	471	//______________________________________________________________________________
	472
	473	void AliEMCALQAChecker::CleanListOfFunctions(TList *list)
edd592b8	474	{ // clean up
a2e583d8	475
	476	if (list) {
	477	TObject *stats = list->FindObject("stats"); list->Remove(stats);
	478	TObject *obj;
	479	while ((obj = list->First())) { while(list->Remove(obj)) { } delete obj; }
	480	if (stats) list->Add(stats);
	481	}
	482	else {
	483	AliWarning(Form("Checker : empty list of data functions; returning"));
	484	return;
	485	}
	486
	487	}
	488
	489