[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:
      if( hdata && ratio ){
	
	// 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
      }//histograms NOT NULL
      
      // ========================================================================================
      // now L1 checks:
      
      if( hL1GammaPatch ){
	
	// first clean lines, text (functions)
	lstF = hL1GammaPatch->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 (specie != calibSpecieId) ..
      }//hL1GammaPatch NOT NULL
      
      if( hL1JetPatch ){
	
	lstF = hL1JetPatch->GetListOfFunctions();
	CleanListOfFunctions(lstF);
	
	if (specie != calibSpecieId) {
	  
	  //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) ..
      }// hL1JetPatch NOT NULL
      
      if(hFrameR){
	
	lstF = hFrameR->GetListOfFunctions();
	CleanListOfFunctions(lstF);
	
	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
      }//hFrameR NOT NULL
    } // species processed		
  } // 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++) {
5fb50596	202
a42ceb0e	203	test[specie] = 0.0 ;
a2e583d8	204	if ( !AliQAv1::Instance()->IsEventSpecieSet(specie)) continue ;
a2e583d8	205	if (list[specie]->GetEntries() == 0) test[specie] = 0. ; // nothing to check
a2655076	206	else {
5fb50596	207	//get calib histos
	208	TH2F * hdata = (TH2F*)list[specie]->At(k2DRatioAmp) ;
	209	TH1F * ratio = (TH1F*)list[specie]->At(kRatioDist) ;
	210
	211	//get L1 histos
	212	TH2F hL1GammaPatch = (TH2F)list[specie]->At(kGL1);
	213	TH2F hL1JetPatch = (TH2F)list[specie]->At(kJL1);
	214	TH1I hFrameR = (TH1I)list[specie]->At(kSTUTRU);
	215
	216
	217	// =======================================================================================
	218	//calib histo checker first:
	219	if( hdata && ratio ){
a2e583d8	220
5fb50596	221	// first clean lines, text (functions)
	222	lstF = hdata->GetListOfFunctions();
	223	CleanListOfFunctions(lstF);
	224	lstF = ratio->GetListOfFunctions();
	225	CleanListOfFunctions(lstF);
	226
	227	if(hdata->GetEntries()!=0 && ratio->GetEntries()!=0) {
	228
	229	lstF = hdata->GetListOfFunctions();
	230
	231	//adding the lines to distinguish different SMs
	232	lstF->Add(fLineCol->Clone());
	233	for(Int_t iLine = 0; iLine < 5; iLine++) {
	234	lstF->Add(fLineRow[iLine]->Clone());
	235	}
	236	//Now adding the text to for each SM
	237	for(Int_t iSM = 0 ; iSM < fgknSM ; iSM++){ //number of SMs loop start
	238	lstF->Add(fTextSM[iSM]->Clone());
	239	}
	240
	241
	242	//now check the ratio histogram
	243	lstF = ratio->GetListOfFunctions();
	244
	245	Double_t binContent = 0. ;
	246	Int_t nGoodTower = 0 ;
	247	Double_t rv = 0. ;
	248	for(Int_t ix = 1; ix <= hdata->GetNbinsX(); ix++) {
	249	for(Int_t iy = 1; iy <= hdata->GetNbinsY(); iy++) {
	250	binContent = hdata->GetBinContent(ix, iy) ;
	251	if (binContent < 1.2 && binContent > 0.8) nGoodTower++ ;
	252	}
	253	}
	254	rv = nGoodTower/nTot ;
	255	//printf("%2.2f %% towers out of range [0.8, 1.2]\n", (1-rv)*100);
	256	if(fText){
	257	lstF->Add(fText->Clone()) ;
	258	fText->Clear() ;
	259
	260	fText->AddText(Form("%2.2f %% towers out of range [0.8, 1.2]", (1-rv)*100));
	261	if (rv < ratioThresh) {
	262	test[specie] = ratioThresh;
	263	// 2 lines text info for quality
	264	fText->SetFillColor(2) ;
	265	fText->AddText(Form("EMCAL = NOK, CALL EXPERTS!!!"));
	266	}
	267	else {
	268	test[specie] = 1 - ratioThresh;
	269	fText->SetFillColor(3) ;
	270	fText->AddText(Form("EMCAL = OK, ENJOY..."));
	271	}
	272	}//fText
	273	}//calib histo checking done
	274	}//histograms NOT NULL
	275
	276	// ========================================================================================
	277	// now L1 checks:
	278
	279	if( hL1GammaPatch ){
	280
	281	// first clean lines, text (functions)
	282	lstF = hL1GammaPatch->GetListOfFunctions();
	283	CleanListOfFunctions(lstF);
	284
285	if (specie != calibSpecieId) {
286	//if(hL1GammaPatch->GetEntries() !=0 ) {
287	if(hL1GammaPatch->GetEntries() > 10) { // need some statistics for hot spot calculation
288	lstF = hL1GammaPatch->GetListOfFunctions();
289
290	// Checker for L1GammaPatch
291	//Double_t dL1GmeanTrig = 1./2961.;
292	//Double_t dL1GmeanTrigTRU = 1./32.;
293	//Int_t sigmaG = 100; // deviation from mean value (increased to 100)
294	//Int_t sigmaGTRU = 5; // deviation from mean value for TRUs
295	Double_t dL1GEntries = hL1GammaPatch->GetEntries();
296	Int_t badL1G[48][64] = {{0}} ;
297	Int_t badL1GTRU[2][16] = {{0}} ;
298	Int_t nBadL1G = 0;
299	Int_t nBadL1GTRU = 0;
300	Double_t binContentTRU[2][16] = {{0.}};
301	for(Int_t ix = 1; ix <= hL1GammaPatch->GetNbinsX(); ix++) {
302	for(Int_t iy = 1; iy <= hL1GammaPatch->GetNbinsY(); iy++) {
303	Double_t binContent = hL1GammaPatch->GetBinContent(ix, iy) ;
304	if (binContent != 0) {
305
306	// fill counter for TRUs
307	binContentTRU[(Int_t)((ix-1)/24)][(Int_t)((iy-1)/4)] += binContent;
308
309	// OLD METHOD (if a patch triggers > sigmaG * mean value (1/#patch positions total) says "hot spot !")
310	// if ((double)binContent/(double)dL1GEntries > sigmaG*dL1GmeanTrig) {
311	// badL1G[ix-1][iy-1] += 1;
312	// nBadL1G += 1;
313	// }
314
315	// NEW METHOD (if Rate > Threshold * ( (Number of towers or TRUs * Average rate) - Rate ) --> "hot spot !")
316	// Thresold = how much does the noisy tower/TRU contribute to the rate
317	// 1.0 --> Rate of noisy tower/TRU = Rate of all other towers/TRUs
318	if (binContent/dL1GEntries > ThreshG / ( 1 + ThreshG )) {
319	badL1G[ix-1][iy-1] += 1;
320	nBadL1G += 1;
321	}
322	}
323	}
324	}
325
326	// check TRUs
327	for(Int_t ix = 1; ix <= 2; ix++) {
328	for(Int_t iy = 1; iy <= 16; iy++) {
329	if(binContentTRU[ix-1][iy-1]/dL1GEntries > ThreshG / ( 1 + ThreshG )) {
330	badL1GTRU[ix-1][iy-1] += 1;
331	nBadL1GTRU += 1;
332	}
333	}
334	}
335
336	if(fTextL1[0]){
337	lstF->Add(fTextL1[0]->Clone()) ;
338	fTextL1[0]->Clear() ;
339
340	if (nBadL1G == 0 && nBadL1GTRU == 0 ) {
341	fTextL1[0]->SetFillColor(3) ;
342	fTextL1[0]->AddText(Form("L1 GAMMA TRIGGER = OK, ENJOY..."));
343	}
344	else if (nBadL1G == 0){
345	fTextL1[0]->SetFillColor(2) ;
346	fTextL1[0]->AddText(Form("HOT SPOT IN L1 GAMMA TRIGGER (TRU) = CALL EXPERT!!"));
347
348	}
349	else{
350	fTextL1[0]->SetFillColor(2) ;
351	fTextL1[0]->AddText(Form("HOT SPOT IN L1 GAMMA TRIGGER = CALL EXPERT!!"));
352	/*
353	for(Int_t ix = 1; ix <= hL1GammaPatch->GetNbinsX(); ix++) {
354	for(Int_t iy = 1; iy <= hL1GammaPatch->GetNbinsY(); iy++) {
355	if(badL1G[ix-1][iy-1] != 0) printf("L1 Gamma patch with position x = %d, y = %d is out of range\n",ix,iy);
356	}
357	}
358	*/
359	}
360	}//fTextL1[0]
361	}// L1 gamma patch checking done
362	}// if (specie != calibSpecieId) ..
363	}//hL1GammaPatch NOT NULL
364
365	if( hL1JetPatch ){
366
367	lstF = hL1JetPatch->GetListOfFunctions();
368	CleanListOfFunctions(lstF);
369
370	if (specie != calibSpecieId) {
371
372	//if(hL1JetPatch->GetEntries() !=0) {
373	if(hL1JetPatch->GetEntries() > 10) { // need some statistics for hot spot calculation
374
375	lstF = hL1JetPatch->GetListOfFunctions();
376
377	// Checker for L1JetPatch
378	//Double_t dL1JmeanTrig = 1/126.;
379	//Int_t sigmaJ = 5; // deviation from mean value
380	Double_t dL1JEntries = hL1JetPatch->GetEntries();
381	Int_t badL1J[12][16] = {{0}} ;
382	Int_t nBadL1J = 0;
383	for(Int_t ix = 1; ix <= hL1JetPatch->GetNbinsX(); ix++) {
384	for(Int_t iy = 1; iy <= hL1JetPatch->GetNbinsY(); iy++) {
385	Double_t binContent = hL1JetPatch->GetBinContent(ix, iy) ;
386	if (binContent != 0) {
387
388	// OLD METHOD (if a patch triggers > sigmaJ * mean value (1/#patch positions total) says "hot spot !")
389	// if ((double)binContent/(double)dL1JEntries > sigmaJ*dL1JmeanTrig) {
390	// badL1J[ix-1][iy-1] += 1 ;
391	// nBadL1J += 1;
392	// }
393
394	// NEW METHOD (if Rate > Threshold * ( (Number of towers or TRUs * Average rate) - Rate ) --> "hot spot !")
395	// Threshold: same definitionas for Gamma
396	if ((double)binContent/(double)dL1JEntries > ThreshJ / ( 1 + ThreshJ )) {
397	badL1J[ix-1][iy-1] += 1 ;
398	nBadL1J += 1;
399	}
400	}
401	}
402	}
403
404	if(fTextL1[1]){
405	lstF->Add(fTextL1[1]->Clone()) ;
406	fTextL1[1]->Clear() ;
407
408	if (nBadL1J == 0) {
409	fTextL1[1]->SetFillColor(3) ;
410	fTextL1[1]->AddText(Form("L1 JET TRIGGER = OK, ENJOY..."));
411	}
412	else {
413	fTextL1[1]->SetFillColor(2) ;
414	fTextL1[1]->AddText(Form("HOT SPOT IN L1 JET TRIGGER = CALL EXPERT!!"));
415	/*
416	for(Int_t ix = 1; ix <= hL1JetPatch->GetNbinsX(); ix++) {
417	for(Int_t iy = 1; iy <= hL1JetPatch->GetNbinsY(); iy++) {
418	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));
419	}
420	}
421	*/
422
423	}
424	}//fTextL1[1]
425	} // L1 Jet patch checking done
426	} // if (specie != calibSpecieId) ..
427	}// hL1JetPatch NOT NULL
428
429	if(hFrameR){
430
431	lstF = hFrameR->GetListOfFunctions();
432	CleanListOfFunctions(lstF);
433
434	if(hFrameR->GetEntries() !=0) {
435	lstF = hFrameR->GetListOfFunctions();
436
437	Int_t badLink[32] = {0};
438	Int_t nBadLink = 0;
439	for(Int_t ix = 1; ix <= hFrameR->GetNbinsX(); ix++) {
440	Double_t binContent = hFrameR->GetBinContent(ix) ;
441	if (binContent == 0) {
442	badLink[ix-1] += 1;
443	nBadLink += 1;
444	}
445	}
446	if(fTextL1[2]){
447	lstF->Add(fTextL1[2]->Clone()) ;
448	fTextL1[2]->Clear() ;
449
450	if (nBadLink < badLinkThresh) {
451	fTextL1[2]->SetFillColor(3) ;
452	fTextL1[2]->AddText(Form("LINK TRU-STU = OK, ENJOY..."));
453	}
454	else {
455	fTextL1[2]->SetFillColor(2) ;
456	fTextL1[2]->AddText(Form("PROBLEM WITH TRU-STU LINK = CALL EXPERT!!"));
457	/*
458	for(Int_t ix = 0; ix <= hFrameR->GetNbinsX(); ix++) {
459	if(badLink[ix] != 0) printf("STU link with TRU %d is out\n",ix);
460	}
461	*/
462	}
463	}//fTextL1[2]
464	} // Checker for link TRU-STU done
465	}//hFrameR NOT NULL
466	} // species processed
de96ebc9	467	} // specie
a2e583d8	468	}
9e47432c	469	//______________________________________________________________________________
a2e583d8	470
9e47432c	471	void AliEMCALQAChecker::Init(const AliQAv1::DETECTORINDEX_t det)
	472	{
	473	/// intialises QA and QA checker settings
	474	AliQAv1::Instance(det) ;
	475	Float_t hiValue[AliQAv1::kNBIT] ;
	476	Float_t lowValue[AliQAv1::kNBIT] ;
	477	lowValue[AliQAv1::kINFO] = 0.0 ;
	478	hiValue[AliQAv1::kINFO] = 0.1 ;
9e47432c	479	lowValue[AliQAv1::kWARNING] = 0.1 ;
6a754398	480	hiValue[AliQAv1::kWARNING] = 0.5 ;
9e47432c	481	lowValue[AliQAv1::kERROR] = 0.5 ;
	482	hiValue[AliQAv1::kERROR] = 0.8 ;
	483	lowValue[AliQAv1::kFATAL] = 0.8 ;
	484	hiValue[AliQAv1::kFATAL] = 1.0 ;
	485	SetHiLo(&hiValue[0], &lowValue[0]) ;
	486	}
94594e5d	487
a2e583d8	488	//______________________________________________________________________________
	489
	490	void AliEMCALQAChecker::CleanListOfFunctions(TList *list)
edd592b8	491	{ // clean up
a2e583d8	492
	493	if (list) {
	494	TObject *stats = list->FindObject("stats"); list->Remove(stats);
	495	TObject *obj;
	496	while ((obj = list->First())) { while(list->Remove(obj)) { } delete obj; }
	497	if (stats) list->Add(stats);
	498	}
	499	else {
	500	AliWarning(Form("Checker : empty list of data functions; returning"));
	501	return;
	502	}
	503
	504	}
	505
	506