[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);
	}


}          

//__________________________________________________________________
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. 
  
   				
  //Float_t kThreshold = 80. ; 
  Int_t nTowersPerSM = 24*48; // number of towers in a SuperModule; 24x48
  Double_t nTot = fgknSM * nTowersPerSM ;
  TList *lstF = 0;
  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 {
      TH2F * hdata  = (TH2F*)list[specie]->At(k2DRatioAmp) ; 
      TH1F * ratio = (TH1F*)list[specie]->At(kRatioDist) ;
      if(hdata->GetEntries()==0 || ratio->GetEntries()==0)
        continue;
      //adding the lines to distinguish different SMs
      lstF = hdata->GetListOfFunctions();
      { // RS: clean list of functions
	if (lstF) {
	  TObject *stats = lstF->FindObject("stats"); lstF->Remove(stats);
	  TObject *obj;
	  while ((obj = lstF->First())) { while(lstF->Remove(obj)) { } delete obj; }
	  if (stats) lstF->Add(stats);
	}
	else {
	  AliWarning(Form("Checker : empty list of data functions; returning"));
	  return;
	}
      }
      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();
      { // RS: clean list of functions
	if (lstF) {
	  TObject *stats = lstF->FindObject("stats"); lstF->Remove(stats);
	  TObject *obj;
	  while ((obj = lstF->First())) { while(lstF->Remove(obj)) { } delete obj; }
	  if (stats) lstF->Add(stats);
	}
	else {
	  AliWarning(Form("Checker : empty list of ratio functions; returning"));
	  return;
	} 
      }
      //
      //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...")); 
        }
        //hdata->Reset("ICE");
        //ratio->Reset("ICE");
      }//fText
    } 
  } //finish the checking
}

//______________________________________________________________________________
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]) ; 
}
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
	85
9e47432c	86	}
	87
	88	//__________________________________________________________________
	89	AliEMCALQAChecker::~AliEMCALQAChecker()
	90	{
	91	/// dtor
38986b78	92	delete [] fTextSM ;
a42ceb0e	93	delete fLineCol ;
b8769ad2	94	for (Int_t i=0; i<5; ++i) delete fLineRow[i] ;
a42ceb0e	95	delete fText ;
9e47432c	96	}
9e47432c	97
9e47432c	98	//______________________________________________________________________________
a42ceb0e	99	void AliEMCALQAChecker::Check(Double_t * test, AliQAv1::ALITASK_t index, TObjArray ** list, const AliDetectorRecoParam * /recoParam/)
9e47432c	100	{
	101	/// Check objects in list
	102
	103	if ( index == AliQAv1::kRAW )
	104	{
a42ceb0e	105	CheckRaws(test, list);
9e47432c	106	printf ("checkers for task %d \n", index) ;
	107	}
	108
	109	if ( index == AliQAv1::kREC)
	110	{
a42ceb0e	111	CheckRecPoints(test, list);
9e47432c	112	}
	113
	114	if ( index == AliQAv1::kESD )
	115	{
a42ceb0e	116	CheckESD(test, list);
9e47432c	117	}
9e47432c	118	AliWarning(Form("Checker for task %d not implement for the moment",index));
9e47432c	119	}
	120
	121	//______________________________________________________________________________
	122	TH1*
	123	AliEMCALQAChecker::GetHisto(TObjArray* list, const char* hname, Int_t specie) const
	124	{
	125	/// Get a given histo from the list
	126	TH1* h = static_cast<TH1*>(list->FindObject(Form("%s_%s",AliRecoParam::GetEventSpecieName(specie),hname)));
	127	if (!h)
	128	{
	129	AliError(Form("Did not find expected histo %s",hname));
	130	}
	131	return h;
	132	}
	133
	134	//______________________________________________________________________________
	135	Double_t
	136	AliEMCALQAChecker::MarkHisto(TH1& histo, Double_t value) const
	137	{
	138	/// Mark histo as originator of some QA error/warning
	139
	140	if ( value != 1.0 )
	141	{
	142	histo.SetBit(AliQAv1::GetQABit());
	143	}
	144
	145	return value;
	146	}
	147
	148
	149	//______________________________________________________________________________
a42ceb0e	150	void AliEMCALQAChecker::CheckRaws(Double_t * test, TObjArray ** list)
9e47432c	151	{
f05c8877	152	// Check RAW QA histograms
	153	// -- Yaxian Mao, CCNU/CERN/LPSC
	154	//adding new checking method: 25/04/2010, Yaxian Mao
	155	//Comparing the amplitude from current run to the reference run, if the ratio in the range [0.8, .12], count as a good tower.
	156	//If more than 90% towers are good, EMCAL works fine, otherwise experts should be contacted.
6a754398	157
38986b78	158
	159	//Float_t kThreshold = 80. ;
	160	Int_t nTowersPerSM = 24*48; // number of towers in a SuperModule; 24x48
afae9650	161	Double_t nTot = fgknSM * nTowersPerSM ;
180c431b	162	TList *lstF = 0;
a2655076	163	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
a42ceb0e	164	test[specie] = 0.0 ;
a2655076	165	if ( !AliQAv1::Instance()->IsEventSpecieSet(specie))
	166	continue ;
	167	if (list[specie]->GetEntries() == 0)
a42ceb0e	168	test[specie] = 0. ; // nothing to check
a2655076	169	else {
38986b78	170	TH2F * hdata = (TH2F*)list[specie]->At(k2DRatioAmp) ;
	171	TH1F * ratio = (TH1F*)list[specie]->At(kRatioDist) ;
	172	if(hdata->GetEntries()==0 \|\| ratio->GetEntries()==0)
	173	continue;
	174	//adding the lines to distinguish different SMs
180c431b	175	lstF = hdata->GetListOfFunctions();
	176	{ // RS: clean list of functions
	177	if (lstF) {
	178	TObject *stats = lstF->FindObject("stats"); lstF->Remove(stats);
	179	TObject *obj;
	180	while ((obj = lstF->First())) { while(lstF->Remove(obj)) { } delete obj; }
	181	if (stats) lstF->Add(stats);
9ae19208	182	}
	183	else {
	184	AliWarning(Form("Checker : empty list of data functions; returning"));
	185	return;
	186	}
f05c8877	187	}
180c431b	188	lstF->Add(fLineCol->Clone());
	189	for(Int_t iLine = 0; iLine < 4; iLine++) {
	190	lstF->Add(fLineRow[iLine]->Clone());
	191	}
	192	//Now adding the text to for each SM
afae9650	193	for(Int_t iSM = 0 ; iSM < fgknSM ; iSM++){ //number of SMs loop start
180c431b	194	lstF->Add(fTextSM[iSM]->Clone());
	195	}
	196	//
	197	lstF = ratio->GetListOfFunctions();
	198	{ // RS: clean list of functions
	199	if (lstF) {
	200	TObject *stats = lstF->FindObject("stats"); lstF->Remove(stats);
	201	TObject *obj;
	202	while ((obj = lstF->First())) { while(lstF->Remove(obj)) { } delete obj; }
	203	if (stats) lstF->Add(stats);
9ae19208	204	}
	205	else {
	206	AliWarning(Form("Checker : empty list of ratio functions; returning"));
	207	return;
180c431b	208	}
180c431b	209	}
180c431b	210	//
38986b78	211	//now check the ratio histogram
	212	Double_t binContent = 0. ;
	213	Int_t NGoodTower = 0 ;
f05c8877	214	Double_t rv = 0. ;
38986b78	215	for(Int_t ix = 1; ix <= hdata->GetNbinsX(); ix++) {
	216	for(Int_t iy = 1; iy <= hdata->GetNbinsY(); iy++) {
	217	binContent = hdata->GetBinContent(ix, iy) ;
	218	if (binContent < 1.2 && binContent > 0.8)
	219	NGoodTower++ ;
6a754398	220	}
6a754398	221	}
38986b78	222	rv = NGoodTower/nTot ;
f05c8877	223	printf("%2.2f %% towers out of range [0.8, 1.2]\n", (1-rv)*100);
f05c8877	224	if(fText){
8e747257	225	lstF->Add(fText->Clone()) ;
f05c8877	226	fText->Clear() ;
7e1d9a9b	227
	228	fText->AddText(Form("%2.2f %% towers out of range [0.8, 1.2]", (1-rv)*100));
	229	if (rv < 0.9) {
	230	test[specie] = 0.9 ;
	231	// 2 lines text info for quality
	232	fText->SetFillColor(2) ;
	233	fText->AddText(Form("EMCAL = NOK, CALL EXPERTS!!!"));
	234	}
	235	else {
	236	test[specie] = 0.1 ;
	237	fText->SetFillColor(3) ;
	238	fText->AddText(Form("EMCAL = OK, ENJOY..."));
	239	}
	240	//hdata->Reset("ICE");
	241	//ratio->Reset("ICE");
	242	}//fText
180c431b	243	}
180c431b	244	} //finish the checking
9e47432c	245	}
	246
	247	//______________________________________________________________________________
	248	void AliEMCALQAChecker::Init(const AliQAv1::DETECTORINDEX_t det)
	249	{
	250	/// intialises QA and QA checker settings
	251	AliQAv1::Instance(det) ;
	252	Float_t hiValue[AliQAv1::kNBIT] ;
	253	Float_t lowValue[AliQAv1::kNBIT] ;
	254	lowValue[AliQAv1::kINFO] = 0.0 ;
	255	hiValue[AliQAv1::kINFO] = 0.1 ;
9e47432c	256	lowValue[AliQAv1::kWARNING] = 0.1 ;
6a754398	257	hiValue[AliQAv1::kWARNING] = 0.5 ;
9e47432c	258	lowValue[AliQAv1::kERROR] = 0.5 ;
	259	hiValue[AliQAv1::kERROR] = 0.8 ;
	260	lowValue[AliQAv1::kFATAL] = 0.8 ;
	261	hiValue[AliQAv1::kFATAL] = 1.0 ;
	262	SetHiLo(&hiValue[0], &lowValue[0]) ;
	263	}
94594e5d	264