[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*[fknSM]),
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(64, 12, "SM C0");
  fTextSM[6]= new TText(64, 36, "SM C1");
  fTextSM[7]= new TText(64, 60, "SM C2");
  fTextSM[8]= new TText(64, 84, "SM C3");
  fTextSM[9]= new TText(64, 108,"SM C4");

	for(int i = 0; i < 4; 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<4; ++i) delete fLineRow[i] ;
  delete fText  ; 
}

//__________________________________________________________________
AliEMCALQAChecker::AliEMCALQAChecker(const AliEMCALQAChecker& qac) : 
AliQACheckerBase(qac.GetName(), qac.GetTitle()), 
fTextSM(new TText*[fknSM]) ,
fLineCol(static_cast<TLine*>(qac.fLineCol->Clone())) , 
fText(new TPaveText(0.2,0.7,0.8,0.9,"NDC"))
{
   // copy ctor 
  for (Int_t sm = 0 ; sm < fknSM ; sm++){
    fTextSM[sm] = static_cast<TText *>(qac.fTextSM[sm]->Clone()) ;
  }
	for(Int_t i = 0 ; i < 4 ; i++) {

		fLineRow[i] = static_cast<TLine*>(qac.fLineRow[i]->Clone()) ; 
	}
}   
//__________________________________________________________________
AliEMCALQAChecker& AliEMCALQAChecker::operator = (const AliEMCALQAChecker &qac) 
{
  fTextSM  = new TText*[fknSM] ;
  fLineCol = static_cast<TLine*>(qac.fLineCol->Clone()) ; 
  fText    = new TPaveText(0.2,0.7,0.8,0.9,"NDC") ;
  for (Int_t sm = 0 ; sm < fknSM ; sm++){
    fTextSM[sm] = static_cast<TText *>(qac.fTextSM[sm]->Clone()) ;
  }
	for(Int_t i = 0; i < 4; i++) {

		fLineRow[i] = static_cast<TLine*>(qac.fLineRow[i]->Clone()) ; 
	}
  return *this ;
}

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