[u/mrichter/AliRoot.git] / ITS / AliITSQAChecker.cxx

/**************************************************************************
 * Copyright(c) 2007-2009, 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.                  *
 **************************************************************************/

/* $Id$ */

// *****************************************
//  Checks the quality assurance 
//  by comparing with reference data
//  W.Ferrarese  P.Cerello  Mag 2008
//  INFN Torino

// --- ROOT system ---
#include "TH1.h"
#include <Riostream.h>

// --- AliRoot header files ---
#include "AliITSQAChecker.h"
#include "AliITSQASPDChecker.h"
#include "AliITSQASDDChecker.h"
#include "AliITSQASSDChecker.h"

ClassImp(AliITSQAChecker)

//____________________________________________________________________________
AliITSQAChecker::AliITSQAChecker(Bool_t kMode, Short_t subDet, Short_t ldc) :
AliQACheckerBase("ITS","SDD Quality Assurance Checker"),
fkOnline(0),
fDet(0),  
fLDC(0),
fSPDOffset(0), 
fSDDOffset(0), 
fSSDOffset(0),
fSPDChecker(0),  // SPD Checker
fSDDChecker(0),  // SDD Checker
fSSDChecker(0)  // SSD Checker
{
  // Standard constructor
  fkOnline = kMode; fDet = subDet; fLDC = ldc;
  if(fDet == 0 || fDet == 1) {
    AliDebug(1,"AliITSQAChecker::Create SPD Checker\n");
  }
  if(fDet == 0 || fDet == 2) {
    AliDebug(1,"AliITSQAChecker::Create SDD Checker\n");
  }
  if(fDet == 0 || fDet == 3) {
    AliDebug(1,"AliITSQAChecker::Create SSD Checker\n");
  }

}

//____________________________________________________________________________
AliITSQAChecker::AliITSQAChecker(const AliITSQAChecker& qac):
AliQACheckerBase(qac.GetName(), qac.GetTitle()), 
fkOnline(qac.fkOnline), 
fDet(qac.fDet), 
fLDC(qac.fLDC), 
fSPDOffset(qac.fSPDOffset), 
fSDDOffset(qac.fSDDOffset), 
fSSDOffset(qac.fSSDOffset), 
fSPDChecker(0), 
fSDDChecker(0), 
fSSDChecker(0) {
  // copy constructor
  AliError("Copy should not be used with this class\n");
}
//____________________________________________________________________________
AliITSQAChecker& AliITSQAChecker::operator=(const AliITSQAChecker& qac){
  // assignment operator
  this->~AliITSQAChecker();
  new(this)AliITSQAChecker(qac);
  return *this;
}

//____________________________________________________________________________
const Double_t AliITSQAChecker::Check(AliQA::ALITASK_t index, TObjArray * list)
{
  
  // Super-basic check on the QA histograms on the input list:
  // look whether they are empty!
  if(index == AliQA::kESD){
    AliDebug(1,"Checker for ESD");
    Int_t tested = 0;
    Int_t empty = 0;
    Double_t rv = 0.;
    // The following flags are set to kTRUE if the corresponding
    // QA histograms exceed a given quality threshold
    Bool_t cluMapSA = kFALSE;
    Bool_t cluMapMI = kFALSE;
    Bool_t cluMI = kFALSE;
    Bool_t cluSA = kFALSE;
    Bool_t verSPDZ = kFALSE;
    if (list->GetEntries() == 0) {
      rv = 0.; // nothing to check
    }
    else {
      TIter next(list);
      TH1 * hdata;
      while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
	if(hdata){
	  TString hname = hdata->GetName();
	  Double_t entries = hdata->GetEntries();
	  ++tested;
	  if(!(entries>0.))++empty;
	  AliDebug(1,Form("ESD hist name %s - entries %12.1g",hname.Data(),entries));

	  if(hname.Contains("hESDClusterMapSA") && entries>0.){
	    cluMapSA = kTRUE;
	    AliDebug(1,Form("Processing histogram %s",hname.Data()));
	    // Check if there are layers with anomalously low 
	    // contributing points to SA reconstructed tracks
	    for(Int_t k=1;k<7;k++){
	      if(hdata->GetBinContent(k)<0.5*(entries/6.)){
		cluMapSA = kFALSE;
		AliInfo(Form("SA tracks have few points on layer %d - look at histogram hESDClustersSA",k));
	      }
	    }  
	  }

	  else if(hname.Contains("hESDClusterMapMI") && entries>0.){
	    // Check if there are layers with anomalously low 
	    // contributing points to MI reconstructed tracks
	    AliDebug(1,Form("Processing histogram %s",hname.Data()));
	    cluMapMI = kTRUE;
	    for(Int_t k=1;k<7;k++){
	      if(hdata->GetBinContent(k)<0.5*(entries/6.)){
		cluMapMI = kFALSE;
		AliInfo(Form("MI tracks have few points on layer %d - look at histogram hESDClustersMI",k));
	      }
	    }  
	  }

	  else if(hname.Contains("hESDClustersMI") && entries>0.){
	    // Check if 6 clusters MI tracks are the majority
	    AliDebug(1,Form("Processing histogram %s",hname.Data()));
	    cluMI = kTRUE;
	    Double_t sixlaytracks = hdata->GetBinContent(7);
	    for(Int_t k=2; k<7; k++){
	      if(hdata->GetBinContent(k)>sixlaytracks){
		cluMI = kFALSE;
		AliInfo(Form("MI Tracks with %d clusters are more than tracks with 6 clusters. Look at histogram hESDClustersMI",k-1));
	      }
	    }
	  }

	  else if(hname.Contains("hESDClustersSA") && entries>0.){
	    // Check if 6 clusters SA tracks are the majority
	    AliDebug(1,Form("Processing histogram %s",hname.Data()));
	    cluSA = kTRUE;
	    Double_t sixlaytracks = hdata->GetBinContent(7);
	    for(Int_t k=2; k<7; k++){
	      if(hdata->GetBinContent(k)>sixlaytracks){
		cluSA = kFALSE;
		AliInfo(Form("SA Tracks with %d clusters are more than tracks with 6 clusters. Look at histogram hESDClustersSA",k-1));
	      }
	    }
	  }

	  else if(hname.Contains("hSPDVertexZ") && entries>0.){
	    // Check if average Z vertex coordinate is -5 < z < 5 cm
	    AliDebug(1,Form("Processing histogram %s",hname.Data()));
	    verSPDZ = kTRUE;
	    if(hdata->GetMean()<-5. && hdata->GetMean()>5.){
	      verSPDZ = kFALSE;
	      AliInfo(Form("Average z vertex coordinate is at z= %10.4g cm",hdata->GetMean()));
	    }
	  }

	}
	else{
	  AliError("ESD Checker - invalid data type");
	}
	  
	rv = 0.;
	if(tested>0){
	  if(tested == empty){
	    rv = 0.1;
	    AliWarning("All ESD histograms are empty");
	  }
	  else {
	    rv = 0.1+0.4*(static_cast<Double_t>(tested-empty)/static_cast<Double_t>(tested));
	    if(cluMapSA)rv+=0.1;
	    if(cluMapMI)rv+=0.1;
	    if(cluMI)rv+=0.1;
	    if(cluSA)rv+=0.1;
	    if(verSPDZ)rv+=0.1;
	  }
	}
  
      }
    }  
      AliInfo(Form("ESD - Tested %d histograms, Return value %f \n",tested,rv));
      return rv;
  }  // end of ESD QA

  Double_t spdCheck, sddCheck, ssdCheck;
  Double_t retval = 1.;
  if(fDet == 0 || fDet == 1) {
    AliDebug(1,"AliITSQAChecker::Create SPD Checker\n");
    if(!fSPDChecker) {
      fSPDChecker = new AliITSQASPDChecker();
    }
    fSPDChecker->SetTaskOffset(fSPDOffset);
    spdCheck = fSPDChecker->Check(index, list);
    if(spdCheck<retval)retval = spdCheck;
  }
  if(fDet == 0 || fDet == 2) {
    AliDebug(1,"AliITSQAChecker::Create SDD Checker\n");
    if(!fSDDChecker) {
      fSDDChecker = new AliITSQASDDChecker();
    }
    fSDDChecker->SetTaskOffset(fSDDOffset);
    sddCheck = fSDDChecker->Check(index, list);
    if(sddCheck<retval)retval = sddCheck;
 }
  if(fDet == 0 || fDet == 3) {
    AliDebug(1,"AliITSQAChecker::Create SSD Checker\n");
    if(!fSSDChecker) {
      fSSDChecker = new AliITSQASSDChecker();
      AliInfo(Form("Number of monitored objects SSD: %d", list->GetEntries()));
    }
    fSSDChecker->SetTaskOffset(fSSDOffset);
    ssdCheck = fSSDChecker->Check(index, list);
    if(ssdCheck<retval)retval = ssdCheck;  }
  // here merging part for common ITS QA result
  // 
  AliDebug(1,Form("AliITSQAChecker::QAChecker returned value is %f \n",retval));
  return retval;
  
}


//____________________________________________________________________________
void AliITSQAChecker::SetTaskOffset(Int_t SPDOffset, Int_t SDDOffset, Int_t SSDOffset)
{
  //Setting the 3 offsets for each task called
  fSPDOffset = SPDOffset;
  fSDDOffset = SDDOffset;
  fSSDOffset = SSDOffset;
}
Commit	Line	Data
1507771f	1	/**************************************************************************
	2	* Copyright(c) 2007-2009, 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	/* $Id$ */
	17
	18	// *****************************************
	19	// Checks the quality assurance
	20	// by comparing with reference data
3647765c	21	// W.Ferrarese P.Cerello Mag 2008
1507771f	22	// INFN Torino
	23
	24	// --- ROOT system ---
5dfa9b71	25	#include "TH1.h"
3647765c	26	#include <Riostream.h>
1507771f	27
	28	// --- AliRoot header files ---
	29	#include "AliITSQAChecker.h"
5dfa9b71	30	#include "AliITSQASPDChecker.h"
	31	#include "AliITSQASDDChecker.h"
	32	#include "AliITSQASSDChecker.h"
1507771f	33
	34	ClassImp(AliITSQAChecker)
	35
5dfa9b71	36	//____________________________________________________________________________
5dfa9b71	37	AliITSQAChecker::AliITSQAChecker(Bool_t kMode, Short_t subDet, Short_t ldc) :
c71529b0	38	AliQACheckerBase("ITS","SDD Quality Assurance Checker"),
	39	fkOnline(0),
	40	fDet(0),
	41	fLDC(0),
	42	fSPDOffset(0),
	43	fSDDOffset(0),
	44	fSSDOffset(0),
	45	fSPDChecker(0), // SPD Checker
	46	fSDDChecker(0), // SDD Checker
	47	fSSDChecker(0) // SSD Checker
5dfa9b71	48	{
8b51d296	49	// Standard constructor
5dfa9b71	50	fkOnline = kMode; fDet = subDet; fLDC = ldc;
	51	if(fDet == 0 \|\| fDet == 1) {
	52	AliDebug(1,"AliITSQAChecker::Create SPD Checker\n");
	53	}
	54	if(fDet == 0 \|\| fDet == 2) {
	55	AliDebug(1,"AliITSQAChecker::Create SDD Checker\n");
	56	}
	57	if(fDet == 0 \|\| fDet == 3) {
	58	AliDebug(1,"AliITSQAChecker::Create SSD Checker\n");
	59	}
	60
	61	}
	62
8b51d296	63	//____________________________________________________________________________
	64	AliITSQAChecker::AliITSQAChecker(const AliITSQAChecker& qac):
	65	AliQACheckerBase(qac.GetName(), qac.GetTitle()),
	66	fkOnline(qac.fkOnline),
	67	fDet(qac.fDet),
	68	fLDC(qac.fLDC),
	69	fSPDOffset(qac.fSPDOffset),
	70	fSDDOffset(qac.fSDDOffset),
	71	fSSDOffset(qac.fSSDOffset),
	72	fSPDChecker(0),
	73	fSDDChecker(0),
	74	fSSDChecker(0) {
	75	// copy constructor
	76	AliError("Copy should not be used with this class\n");
	77	}
	78	//____________________________________________________________________________
	79	AliITSQAChecker& AliITSQAChecker::operator=(const AliITSQAChecker& qac){
	80	// assignment operator
	81	this->~AliITSQAChecker();
	82	new(this)AliITSQAChecker(qac);
	83	return *this;
	84	}
	85
5dfa9b71	86	//____________________________________________________________________________
6b374954	87	const Double_t AliITSQAChecker::Check(AliQA::ALITASK_t index, TObjArray * list)
5dfa9b71	88	{
3647765c	89
5dfa9b71	90	// Super-basic check on the QA histograms on the input list:
5dfa9b71	91	// look whether they are empty!
8ea6e205	92	if(index == AliQA::kESD){
	93	AliDebug(1,"Checker for ESD");
	94	Int_t tested = 0;
	95	Int_t empty = 0;
	96	Double_t rv = 0.;
	97	// The following flags are set to kTRUE if the corresponding
	98	// QA histograms exceed a given quality threshold
	99	Bool_t cluMapSA = kFALSE;
	100	Bool_t cluMapMI = kFALSE;
	101	Bool_t cluMI = kFALSE;
	102	Bool_t cluSA = kFALSE;
	103	Bool_t verSPDZ = kFALSE;
	104	if (list->GetEntries() == 0) {
	105	rv = 0.; // nothing to check
	106	}
	107	else {
	108	TIter next(list);
	109	TH1 * hdata;
	110	while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
	111	if(hdata){
	112	TString hname = hdata->GetName();
	113	Double_t entries = hdata->GetEntries();
	114	++tested;
	115	if(!(entries>0.))++empty;
	116	AliDebug(1,Form("ESD hist name %s - entries %12.1g",hname.Data(),entries));
	117
	118	if(hname.Contains("hESDClusterMapSA") && entries>0.){
	119	cluMapSA = kTRUE;
	120	AliDebug(1,Form("Processing histogram %s",hname.Data()));
	121	// Check if there are layers with anomalously low
	122	// contributing points to SA reconstructed tracks
	123	for(Int_t k=1;k<7;k++){
	124	if(hdata->GetBinContent(k)<0.5*(entries/6.)){
	125	cluMapSA = kFALSE;
	126	AliInfo(Form("SA tracks have few points on layer %d - look at histogram hESDClustersSA",k));
	127	}
	128	}
	129	}
	130
	131	else if(hname.Contains("hESDClusterMapMI") && entries>0.){
	132	// Check if there are layers with anomalously low
	133	// contributing points to MI reconstructed tracks
	134	AliDebug(1,Form("Processing histogram %s",hname.Data()));
	135	cluMapMI = kTRUE;
	136	for(Int_t k=1;k<7;k++){
	137	if(hdata->GetBinContent(k)<0.5*(entries/6.)){
	138	cluMapMI = kFALSE;
	139	AliInfo(Form("MI tracks have few points on layer %d - look at histogram hESDClustersMI",k));
	140	}
	141	}
	142	}
	143
	144	else if(hname.Contains("hESDClustersMI") && entries>0.){
	145	// Check if 6 clusters MI tracks are the majority
	146	AliDebug(1,Form("Processing histogram %s",hname.Data()));
	147	cluMI = kTRUE;
	148	Double_t sixlaytracks = hdata->GetBinContent(7);
	149	for(Int_t k=2; k<7; k++){
	150	if(hdata->GetBinContent(k)>sixlaytracks){
	151	cluMI = kFALSE;
	152	AliInfo(Form("MI Tracks with %d clusters are more than tracks with 6 clusters. Look at histogram hESDClustersMI",k-1));
	153	}
	154	}
	155	}
156
157	else if(hname.Contains("hESDClustersSA") && entries>0.){
158	// Check if 6 clusters SA tracks are the majority
159	AliDebug(1,Form("Processing histogram %s",hname.Data()));
160	cluSA = kTRUE;
161	Double_t sixlaytracks = hdata->GetBinContent(7);
162	for(Int_t k=2; k<7; k++){
163	if(hdata->GetBinContent(k)>sixlaytracks){
164	cluSA = kFALSE;
165	AliInfo(Form("SA Tracks with %d clusters are more than tracks with 6 clusters. Look at histogram hESDClustersSA",k-1));
166	}
167	}
168	}
169
170	else if(hname.Contains("hSPDVertexZ") && entries>0.){
171	// Check if average Z vertex coordinate is -5 < z < 5 cm
172	AliDebug(1,Form("Processing histogram %s",hname.Data()));
173	verSPDZ = kTRUE;
174	if(hdata->GetMean()<-5. && hdata->GetMean()>5.){
175	verSPDZ = kFALSE;
176	AliInfo(Form("Average z vertex coordinate is at z= %10.4g cm",hdata->GetMean()));
177	}
178	}
179
180	}
181	else{
182	AliError("ESD Checker - invalid data type");
183	}
184
185	rv = 0.;
186	if(tested>0){
187	if(tested == empty){
188	rv = 0.1;
189	AliWarning("All ESD histograms are empty");
190	}
191	else {
192	rv = 0.1+0.4*(static_cast<Double_t>(tested-empty)/static_cast<Double_t>(tested));
193	if(cluMapSA)rv+=0.1;
194	if(cluMapMI)rv+=0.1;
195	if(cluMI)rv+=0.1;
196	if(cluSA)rv+=0.1;
197	if(verSPDZ)rv+=0.1;
198	}
199	}
200
201	}
202	}
203	AliInfo(Form("ESD - Tested %d histograms, Return value %f \n",tested,rv));
204	return rv;
205	} // end of ESD QA
206
c71529b0	207	Double_t spdCheck, sddCheck, ssdCheck;
e7e85671	208	Double_t retval = 1.;
5dfa9b71	209	if(fDet == 0 \|\| fDet == 1) {
5dfa9b71	210	AliDebug(1,"AliITSQAChecker::Create SPD Checker\n");
3647765c	211	if(!fSPDChecker) {
	212	fSPDChecker = new AliITSQASPDChecker();
	213	}
	214	fSPDChecker->SetTaskOffset(fSPDOffset);
	215	spdCheck = fSPDChecker->Check(index, list);
e7e85671	216	if(spdCheck<retval)retval = spdCheck;
5dfa9b71	217	}
	218	if(fDet == 0 \|\| fDet == 2) {
	219	AliDebug(1,"AliITSQAChecker::Create SDD Checker\n");
3647765c	220	if(!fSDDChecker) {
	221	fSDDChecker = new AliITSQASDDChecker();
	222	}
	223	fSDDChecker->SetTaskOffset(fSDDOffset);
	224	sddCheck = fSDDChecker->Check(index, list);
e7e85671	225	if(sddCheck<retval)retval = sddCheck;
3647765c	226	}
5dfa9b71	227	if(fDet == 0 \|\| fDet == 3) {
5dfa9b71	228	AliDebug(1,"AliITSQAChecker::Create SSD Checker\n");
3647765c	229	if(!fSSDChecker) {
	230	fSSDChecker = new AliITSQASSDChecker();
	231	AliInfo(Form("Number of monitored objects SSD: %d", list->GetEntries()));
	232	}
	233	fSSDChecker->SetTaskOffset(fSSDOffset);
	234	ssdCheck = fSSDChecker->Check(index, list);
e7e85671	235	if(ssdCheck<retval)retval = ssdCheck; }
5dfa9b71	236	// here merging part for common ITS QA result
c71529b0	237	//
3647765c	238	AliDebug(1,Form("AliITSQAChecker::QAChecker returned value is %f \n",retval));
c71529b0	239	return retval;
3647765c	240
5dfa9b71	241	}
	242
	243
c71529b0	244	//____________________________________________________________________________
	245	void AliITSQAChecker::SetTaskOffset(Int_t SPDOffset, Int_t SDDOffset, Int_t SSDOffset)
	246	{
	247	//Setting the 3 offsets for each task called
	248	fSPDOffset = SPDOffset;
	249	fSDDOffset = SDDOffset;
	250	fSSDOffset = SSDOffset;
	251	}