[u/mrichter/AliRoot.git] / ITS / AliITSQASDDChecker.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
//  P. Cerello Apr 2008
//  INFN Torino

// --- ROOT system ---
#include "TH1.h"
#include <TCanvas.h>
#include <TH1D.h>
#include <TH2.h>
#include <TF1.h>


// --- AliRoot header files ---
#include "AliITSQASDDChecker.h"
#include "AliLog.h"
#include "AliCDBEntry.h"
#include "AliQAManager.h"
#include "AliQACheckerBase.h"
#include "TSystem.h"
#include "AliITSCalibrationSDD.h"
#include "AliITSgeomTGeo.h"

ClassImp(AliITSQASDDChecker)
//__________________________________________________________________
AliITSQASDDChecker& AliITSQASDDChecker::operator = (const AliITSQASDDChecker& qac ) 
{
  // Equal operator.
  this->~AliITSQASDDChecker();
  new(this) AliITSQASDDChecker(qac);
  return *this;
}

AliITSQASDDChecker::~AliITSQASDDChecker() 
{
  if(fStepBitSDD) 
    {
      delete[] fStepBitSDD ;
      fStepBitSDD = NULL;
    }
  if(fLowSDDValue)
    {
      delete[]fLowSDDValue;
      fLowSDDValue=NULL;
    }
  if(fHighSDDValue)
    { 
      delete[]fHighSDDValue;
      fHighSDDValue=NULL;
    }
  if(fCalibration)
    {
      delete fCalibration;
      fCalibration=NULL;
    }
} // dtor

//__________________________________________________________________
Double_t AliITSQASDDChecker::Check(AliQAv1::ALITASK_t index, TObjArray * list, const AliDetectorRecoParam * /*recoparam*/) 
{  
  AliInfo(Form("AliITSQASDDChecker called with offset: %d\n", fSubDetOffset) );

  AliDebug(1,Form("AliITSQASDDChecker called with offset: %d\n", fSubDetOffset));

  Double_t test = 0.;
  TH1 *hdata=NULL;
  Double_t entries=0.;
  Double_t entries2[2];
  for(Int_t i=0;i<2;i++)entries2[i]=0.;
  switch(index)
    {

    case AliQAv1::kRAW:
      AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
      if(!fCalibration){
	AliCDBEntry *calibSDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD");
	Bool_t cacheStatus = AliCDBManager::Instance()->GetCacheFlag();
	if(!calibSDD)
	  {
	    AliError("Calibration object retrieval failed! SDD will not be processed");
	    fCalibration = NULL;
	    test= fHighSDDValue[AliQAv1::kWARNING];
	  }
	fCalibration = (TObjArray *)calibSDD->GetObject();
	
	if(!cacheStatus)calibSDD->SetObject(NULL);
	calibSDD->SetOwner(kTRUE);
	if(!cacheStatus)
	  {
	    delete calibSDD;
	  }
      }
      AliInfo("Calib SDD Created\n ");
      
      if (list->GetEntries() == 0.){ //check if the list is empty
	//printf("test = %f \t value %f\n",test,fHighSDDValue[AliQAv1::kFATAL]);
	test=test+fHighSDDValue[AliQAv1::kFATAL];
	break;
      }//end if getentries
      else{
	TIter next(list);
	Int_t offset = 0;
	for(offset =0;offset < fSubDetOffset; offset++){hdata = dynamic_cast<TH1*>(next());}//end for
	Int_t emptymodules[2];
	Int_t filledmodules[2];
	Int_t emptyladders[2];
	Int_t filledladders[2];
	for(Int_t i=0;i<2;i++){
	  emptymodules[i]=0;
	  filledmodules[i]=0;
	  emptyladders[i]=0;
	  filledladders[i]=0;
	}
	TH1 *hmodule=NULL;
	TH2 *hlayer[2];
	for(Int_t i=0;i<2;i++)hlayer[i]=NULL;    
	while( hdata = dynamic_cast<TH1* >(next()) ){
	  if (hdata){
	    TString hname=hdata->GetName();
	    if(hname.Contains("SDDchargeMap"))continue;
	    if(hname.Contains("SDDModPattern")){
	      hmodule=hdata;
	      entries= hdata->GetEntries();
	      if(entries==0){
		AliWarning(Form("===================>>>>>> No entries in  %s \n",hname.Data()));
		//printf("test = %f \t value %f\n",test,fHighSDDValue[AliQAv1::kFATAL]);
		test=test+fStepBitSDD[AliQAv1::kFATAL];
	      }//endif entries
	      else{
		int modmax=hdata->GetNbinsX();
		Int_t empty=0;
		Int_t filled=0;
		Double_t content=0;
		for(Int_t i=1;i<=modmax;i++){
		  content=hdata->GetBinContent(i);
		  if(content==0.){empty++;}
		  else if(content!=0.){filled++;}
		}//end for
		AliInfo(Form(" %s : empty modules %i \t filled modules %i",hname.Data(), empty, filled));
	      }//end else pattern entries !=0	      
	    }//end if modpattern
	    else if(hname.Contains("SDDphizL3")||hname.Contains("SDDphizL4")){
	      Int_t layer=0;
	      if(hname.Contains("3"))layer=0;
	      else  if(hname.Contains("4"))layer=1;
	      entries2[layer]=hdata->GetEntries();
	      if(entries2[layer]==0){
		AliWarning(Form("===================>>>>>> No entries in  %s \n",hname.Data()));
		//printf("test = %f \t value %f\n",test,fStepBitSDD[AliQAv1::kFATAL]);
		test=test+fStepBitSDD[AliQAv1::kFATAL];
		if(entries==0){ 
		  //return test; 
		  //break;
		}
	      }//end if getentries
	      else{
		Int_t layer=0;
		if(hname.Contains("3"))layer=0;
		else  if(hname.Contains("4"))layer=1;
		hlayer[layer]=dynamic_cast<TH2*>(hdata); 
		hlayer[layer]->RebinX(2);
		int modmay=hlayer[layer]->GetNbinsY();
		TH1D* hproj= hlayer[layer]->ProjectionY();
		Double_t ladcontent=0;
		for(Int_t i=1;i<=modmay;i++) {//loop on the ladders
		  ladcontent=hproj->GetBinContent(i);
		  if(ladcontent==0){emptyladders[layer]++;}
		  else if(ladcontent!=0){filledladders[layer]++;} 
		}//end for
		AliInfo(Form(" %s : empty ladders %i \t filled ladders %i\n",hname.Data(), emptyladders[layer], filledladders[layer]));//end else layer 3
		delete hproj;
		hproj=NULL;	
	      }//end else entries !=0	      
	    }//end if layer 3
	  }//end if hdata	
	}//end while
	if(entries==0.&&entries2[0]==0.&&entries2[1]==0.) break;
	else{
	  if(hmodule||(hlayer[0]&&hlayer[1])){
	    Int_t excluded=0;
	    Int_t active=0;
	    Int_t exactive=0;//excluded but taking data
	    //AliITSCalibrationSDD *cal;
	    for(Int_t imod=0;imod<fgknSDDmodules;imod++){
	      Int_t lay=0;
	      Int_t lad=0;
	      Int_t det=0;
	      Int_t module=0;
	      module=imod+fgkmodoffset;
	      AliITSCalibrationSDD * cal=(AliITSCalibrationSDD*)fCalibration->At(imod);
	      if(cal==0) { delete cal; continue;}
	      AliITSgeomTGeo::GetModuleId(module,lay,lad,det);
	      if (cal->IsBad()){
		excluded++;
		Double_t content=0.;
		Double_t contentlayer[2];
		for(Int_t i=0;i<2;i++)contentlayer[i]=0.;
		if(hmodule)content=hmodule->GetBinContent(imod+1);//if expert bit is active the histogram has been created 
		contentlayer[lay-3]=hlayer[lay-3]->GetBinContent(det,lad);
		if(content!=0.||contentlayer[lay-3]!=0.)
		  {
		    filledmodules[lay-3]++;
		    AliWarning(Form("The module %d (layer %i, ladder %i det %i ) excluded from the acquisition, took data \n ",module,lay,lad,det));
		    exactive++;
		  }
		else if(content==0.&&contentlayer[lay-3]==0.)emptymodules[lay-3]++;
		//AliInfo(Form("The module %d (layer %i, ladder %i det %i ) is bad, content %f content layer %f  filled modules position %d ",module,lay,lad,det,contentlayer[lay-3],content,lay-3) );
	      }//end if bad
	      else
		{
		  Double_t contentgood=0.;
		  active++;
		  //printf("lay: %i\t det %i \t lad %i \n",lay,det,lad );
		  contentgood=hlayer[lay-3]->GetBinContent(det,lad);
		  if(contentgood==0.){emptymodules[lay-3]++;}
		  else if(contentgood!=0.){filledmodules[lay-3]++;}
		}
	      
	      //delete cal;
	      //cal=NULL;
	    }//end for
	    for(Int_t i=0;i<2;i++){AliInfo(Form(" %s :Layer %i \tempty modules %i \t filled modules %i\n",hlayer[i]->GetName(), i+3,emptymodules[i], filledmodules[i]));}//end else layers
	    if(exactive==0){
	      AliInfo(Form("All the active modules (%i) are in acquisition. The number of excluded modules are %i \n",active,excluded));
	      test=fHighSDDValue[AliQAv1::kINFO];}
	    if(exactive!=0){
	      AliWarning(Form("%i modules excluded from the acquisition took data. Active modules%i \n ",exactive,active));
	      test=fHighSDDValue[AliQAv1::kWARNING];
	    }
	    if(excluded==exactive){
	      AliWarning(Form("All the modules exluded from the acquisition (%d) took data!  Active modules %i\n",excluded,active));
	      test=fHighSDDValue[AliQAv1::kWARNING];
	    }
	    if(active==0){
	      AliWarning(Form("No modules took data: excluded %i \t exactive %i \n", excluded, exactive)); 
	      test=fHighSDDValue[AliQAv1::kFATAL];
	    }
	  } 
	}
      }//end getentries !=0
      //delete calSDD;
      
      
      //delete calibSDD;
      //delete calSDD;
   
      break;
    case AliQAv1::kNULLTASK:
      AliInfo(Form("No Check on %s\n",AliQAv1::GetAliTaskName(index))); 
      test=1.;
      break;
    case AliQAv1::kSIM:
      AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index))); 
      test=1.;
      break;
    case AliQAv1::kREC:
      AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index))); 
      test=1.;
      break;
    case AliQAv1::kANA:
      AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
      test=1.; 
      break;
    case AliQAv1::kESD:
      AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
      test=1.; 
      break;
    case AliQAv1::kNTASK:
      AliInfo(Form("No Check on %s\n",AliQAv1::GetAliTaskName(index))); 
      test=1.;
      break;
      
    }//end switch
  delete hdata;
  return test;	
}
 
//__________________________________________________________________
void AliITSQASDDChecker::SetTaskOffset(Int_t taskoffset)
{
  fSubDetOffset = taskoffset;
}


//__________________________________________________________________
void AliITSQASDDChecker::SetStepBit(Double_t *steprange)
{

  fStepBitSDD = new Double_t[AliQAv1::kNBIT];
  for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
    {
      fStepBitSDD[bit]=steprange[bit];
    }
}

//__________________________________________________________________
void  AliITSQASDDChecker::SetSDDLimits(Float_t *lowvalue, Float_t * highvalue)
{

  fLowSDDValue = new Float_t[AliQAv1::kNBIT];
  fHighSDDValue= new Float_t[AliQAv1::kNBIT];

  for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
    {
      fLowSDDValue[bit]=lowvalue[bit];
      fHighSDDValue[bit]= highvalue[bit];
    }

}
Commit	Line	Data
3647765c	1
5b716935	2	/**************************************************************************
	3	* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
	4	* *
	5	* Author: The ALICE Off-line Project. *
	6	* Contributors are mentioned in the code where appropriate. *
	7	* *
	8	* Permission to use, copy, modify and distribute this software and its *
	9	* documentation strictly for non-commercial purposes is hereby granted *
	10	* without fee, provided that the above copyright notice appears in all *
	11	* copies and that both the copyright notice and this permission notice *
	12	* appear in the supporting documentation. The authors make no claims *
	13	* about the suitability of this software for any purpose. It is *
	14	* provided "as is" without express or implied warranty. *
	15	**************************************************************************/
	16
	17	/* $Id$ */
	18
	19	// *****************************************
	20	// Checks the quality assurance
	21	// by comparing with reference data
	22	// P. Cerello Apr 2008
	23	// INFN Torino
	24
	25	// --- ROOT system ---
3647765c	26	#include "TH1.h"
3647765c	27	#include <TCanvas.h>
80b9610c	28	#include <TH1D.h>
	29	#include <TH2.h>
	30	#include <TF1.h>
	31
	32
5b716935	33
	34	// --- AliRoot header files ---
	35	#include "AliITSQASDDChecker.h"
c71529b0	36	#include "AliLog.h"
3647765c	37	#include "AliCDBEntry.h"
fc7e0df2	38	#include "AliQAManager.h"
3647765c	39	#include "AliQACheckerBase.h"
3647765c	40	#include "TSystem.h"
80b9610c	41	#include "AliITSCalibrationSDD.h"
80b9610c	42	#include "AliITSgeomTGeo.h"
5b716935	43
3647765c	44	ClassImp(AliITSQASDDChecker)
5b716935	45	//__________________________________________________________________
	46	AliITSQASDDChecker& AliITSQASDDChecker::operator = (const AliITSQASDDChecker& qac )
	47	{
	48	// Equal operator.
	49	this->~AliITSQASDDChecker();
	50	new(this) AliITSQASDDChecker(qac);
	51	return *this;
	52	}
	53
80b9610c	54	AliITSQASDDChecker::~AliITSQASDDChecker()
	55	{
	56	if(fStepBitSDD)
	57	{
	58	delete[] fStepBitSDD ;
	59	fStepBitSDD = NULL;
	60	}
	61	if(fLowSDDValue)
	62	{
	63	delete[]fLowSDDValue;
	64	fLowSDDValue=NULL;
	65	}
	66	if(fHighSDDValue)
	67	{
	68	delete[]fHighSDDValue;
	69	fHighSDDValue=NULL;
	70	}
	71	if(fCalibration)
	72	{
	73	delete fCalibration;
	74	fCalibration=NULL;
	75	}
	76	} // dtor
	77
5b716935	78	//__________________________________________________________________
486788fc	79	Double_t AliITSQASDDChecker::Check(AliQAv1::ALITASK_t index, TObjArray * list, const AliDetectorRecoParam * /recoparam/)
c71529b0	80	{
80b9610c	81	AliInfo(Form("AliITSQASDDChecker called with offset: %d\n", fSubDetOffset) );
80b9610c	82
3647765c	83	AliDebug(1,Form("AliITSQASDDChecker called with offset: %d\n", fSubDetOffset));
3647765c	84
80b9610c	85	Double_t test = 0.;
	86	TH1 *hdata=NULL;
	87	Double_t entries=0.;
	88	Double_t entries2[2];
	89	for(Int_t i=0;i<2;i++)entries2[i]=0.;
	90	switch(index)
	91	{
3647765c	92
80b9610c	93	case AliQAv1::kRAW:
	94	AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
	95	if(!fCalibration){
	96	AliCDBEntry *calibSDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD");
	97	Bool_t cacheStatus = AliCDBManager::Instance()->GetCacheFlag();
	98	if(!calibSDD)
	99	{
	100	AliError("Calibration object retrieval failed! SDD will not be processed");
	101	fCalibration = NULL;
	102	test= fHighSDDValue[AliQAv1::kWARNING];
	103	}
	104	fCalibration = (TObjArray *)calibSDD->GetObject();
	105
	106	if(!cacheStatus)calibSDD->SetObject(NULL);
	107	calibSDD->SetOwner(kTRUE);
	108	if(!cacheStatus)
	109	{
	110	delete calibSDD;
	111	}
5b716935	112	}
80b9610c	113	AliInfo("Calib SDD Created\n ");
	114
	115	if (list->GetEntries() == 0.){ //check if the list is empty
	116	//printf("test = %f \t value %f\n",test,fHighSDDValue[AliQAv1::kFATAL]);
	117	test=test+fHighSDDValue[AliQAv1::kFATAL];
	118	break;
	119	}//end if getentries
	120	else{
	121	TIter next(list);
	122	Int_t offset = 0;
	123	for(offset =0;offset < fSubDetOffset; offset++){hdata = dynamic_cast<TH1*>(next());}//end for
	124	Int_t emptymodules[2];
	125	Int_t filledmodules[2];
	126	Int_t emptyladders[2];
	127	Int_t filledladders[2];
	128	for(Int_t i=0;i<2;i++){
	129	emptymodules[i]=0;
	130	filledmodules[i]=0;
	131	emptyladders[i]=0;
	132	filledladders[i]=0;
3647765c	133	}
80b9610c	134	TH1 *hmodule=NULL;
	135	TH2 *hlayer[2];
	136	for(Int_t i=0;i<2;i++)hlayer[i]=NULL;
	137	while( hdata = dynamic_cast<TH1* >(next()) ){
	138	if (hdata){
	139	TString hname=hdata->GetName();
	140	if(hname.Contains("SDDchargeMap"))continue;
	141	if(hname.Contains("SDDModPattern")){
	142	hmodule=hdata;
	143	entries= hdata->GetEntries();
	144	if(entries==0){
	145	AliWarning(Form("===================>>>>>> No entries in %s \n",hname.Data()));
	146	//printf("test = %f \t value %f\n",test,fHighSDDValue[AliQAv1::kFATAL]);
	147	test=test+fStepBitSDD[AliQAv1::kFATAL];
	148	}//endif entries
	149	else{
	150	int modmax=hdata->GetNbinsX();
	151	Int_t empty=0;
	152	Int_t filled=0;
	153	Double_t content=0;
	154	for(Int_t i=1;i<=modmax;i++){
	155	content=hdata->GetBinContent(i);
	156	if(content==0.){empty++;}
	157	else if(content!=0.){filled++;}
	158	}//end for
	159	AliInfo(Form(" %s : empty modules %i \t filled modules %i",hname.Data(), empty, filled));
	160	}//end else pattern entries !=0
	161	}//end if modpattern
	162	else if(hname.Contains("SDDphizL3")\|\|hname.Contains("SDDphizL4")){
	163	Int_t layer=0;
	164	if(hname.Contains("3"))layer=0;
	165	else if(hname.Contains("4"))layer=1;
	166	entries2[layer]=hdata->GetEntries();
	167	if(entries2[layer]==0){
	168	AliWarning(Form("===================>>>>>> No entries in %s \n",hname.Data()));
	169	//printf("test = %f \t value %f\n",test,fStepBitSDD[AliQAv1::kFATAL]);
	170	test=test+fStepBitSDD[AliQAv1::kFATAL];
	171	if(entries==0){
	172	//return test;
	173	//break;
	174	}
	175	}//end if getentries
	176	else{
	177	Int_t layer=0;
	178	if(hname.Contains("3"))layer=0;
	179	else if(hname.Contains("4"))layer=1;
	180	hlayer[layer]=dynamic_cast<TH2*>(hdata);
	181	hlayer[layer]->RebinX(2);
	182	int modmay=hlayer[layer]->GetNbinsY();
	183	TH1D* hproj= hlayer[layer]->ProjectionY();
	184	Double_t ladcontent=0;
	185	for(Int_t i=1;i<=modmay;i++) {//loop on the ladders
	186	ladcontent=hproj->GetBinContent(i);
	187	if(ladcontent==0){emptyladders[layer]++;}
	188	else if(ladcontent!=0){filledladders[layer]++;}
	189	}//end for
	190	AliInfo(Form(" %s : empty ladders %i \t filled ladders %i\n",hname.Data(), emptyladders[layer], filledladders[layer]));//end else layer 3
	191	delete hproj;
	192	hproj=NULL;
	193	}//end else entries !=0
	194	}//end if layer 3
	195	}//end if hdata
	196	}//end while
	197	if(entries==0.&&entries2[0]==0.&&entries2[1]==0.) break;
3647765c	198	else{
80b9610c	199	if(hmodule\|\|(hlayer[0]&&hlayer[1])){
	200	Int_t excluded=0;
	201	Int_t active=0;
	202	Int_t exactive=0;//excluded but taking data
	203	//AliITSCalibrationSDD *cal;
	204	for(Int_t imod=0;imod<fgknSDDmodules;imod++){
	205	Int_t lay=0;
	206	Int_t lad=0;
	207	Int_t det=0;
	208	Int_t module=0;
	209	module=imod+fgkmodoffset;
	210	AliITSCalibrationSDD * cal=(AliITSCalibrationSDD*)fCalibration->At(imod);
	211	if(cal==0) { delete cal; continue;}
	212	AliITSgeomTGeo::GetModuleId(module,lay,lad,det);
	213	if (cal->IsBad()){
	214	excluded++;
	215	Double_t content=0.;
	216	Double_t contentlayer[2];
	217	for(Int_t i=0;i<2;i++)contentlayer[i]=0.;
	218	if(hmodule)content=hmodule->GetBinContent(imod+1);//if expert bit is active the histogram has been created
	219	contentlayer[lay-3]=hlayer[lay-3]->GetBinContent(det,lad);
	220	if(content!=0.\|\|contentlayer[lay-3]!=0.)
	221	{
	222	filledmodules[lay-3]++;
	223	AliWarning(Form("The module %d (layer %i, ladder %i det %i ) excluded from the acquisition, took data \n ",module,lay,lad,det));
	224	exactive++;
	225	}
	226	else if(content==0.&&contentlayer[lay-3]==0.)emptymodules[lay-3]++;
	227	//AliInfo(Form("The module %d (layer %i, ladder %i det %i ) is bad, content %f content layer %f filled modules position %d ",module,lay,lad,det,contentlayer[lay-3],content,lay-3) );
	228	}//end if bad
	229	else
	230	{
	231	Double_t contentgood=0.;
	232	active++;
	233	//printf("lay: %i\t det %i \t lad %i \n",lay,det,lad );
	234	contentgood=hlayer[lay-3]->GetBinContent(det,lad);
	235	if(contentgood==0.){emptymodules[lay-3]++;}
	236	else if(contentgood!=0.){filledmodules[lay-3]++;}
	237	}
	238
	239	//delete cal;
	240	//cal=NULL;
	241	}//end for
	242	for(Int_t i=0;i<2;i++){AliInfo(Form(" %s :Layer %i \tempty modules %i \t filled modules %i\n",hlayer[i]->GetName(), i+3,emptymodules[i], filledmodules[i]));}//end else layers
	243	if(exactive==0){
	244	AliInfo(Form("All the active modules (%i) are in acquisition. The number of excluded modules are %i \n",active,excluded));
	245	test=fHighSDDValue[AliQAv1::kINFO];}
	246	if(exactive!=0){
	247	AliWarning(Form("%i modules excluded from the acquisition took data. Active modules%i \n ",exactive,active));
	248	test=fHighSDDValue[AliQAv1::kWARNING];
	249	}
	250	if(excluded==exactive){
	251	AliWarning(Form("All the modules exluded from the acquisition (%d) took data! Active modules %i\n",excluded,active));
	252	test=fHighSDDValue[AliQAv1::kWARNING];
	253	}
	254	if(active==0){
	255	AliWarning(Form("No modules took data: excluded %i \t exactive %i \n", excluded, exactive));
	256	test=fHighSDDValue[AliQAv1::kFATAL];
	257	}
	258	}
3647765c	259	}
80b9610c	260	}//end getentries !=0
	261	//delete calSDD;
	262
	263
	264
	265	//delete calibSDD;
	266	//delete calSDD;
	267
	268	break;
	269	case AliQAv1::kNULLTASK:
	270	AliInfo(Form("No Check on %s\n",AliQAv1::GetAliTaskName(index)));
	271	test=1.;
	272	break;
	273	case AliQAv1::kSIM:
	274	AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
	275	test=1.;
	276	break;
	277	case AliQAv1::kREC:
	278	AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
	279	test=1.;
	280	break;
	281	case AliQAv1::kANA:
	282	AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
	283	test=1.;
	284	break;
	285	case AliQAv1::kESD:
	286	AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
	287	test=1.;
	288	break;
	289	case AliQAv1::kNTASK:
	290	AliInfo(Form("No Check on %s\n",AliQAv1::GetAliTaskName(index)));
	291	test=1.;
	292	break;
	293
	294	}//end switch
	295	delete hdata;
3647765c	296	return test;
5b716935	297	}
5b716935	298
3647765c	299	//__________________________________________________________________
80b9610c	300	void AliITSQASDDChecker::SetTaskOffset(Int_t taskoffset)
	301	{
	302	fSubDetOffset = taskoffset;
	303	}
	304
	305
	306	//__________________________________________________________________
	307	void AliITSQASDDChecker::SetStepBit(Double_t *steprange)
	308	{
	309
	310	fStepBitSDD = new Double_t[AliQAv1::kNBIT];
	311	for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
	312	{
	313	fStepBitSDD[bit]=steprange[bit];
	314	}
	315	}
	316
	317	//__________________________________________________________________
	318	void AliITSQASDDChecker::SetSDDLimits(Float_t lowvalue, Float_t highvalue)
3647765c	319	{
80b9610c	320
	321	fLowSDDValue = new Float_t[AliQAv1::kNBIT];
	322	fHighSDDValue= new Float_t[AliQAv1::kNBIT];
	323
	324	for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
	325	{
	326	fLowSDDValue[bit]=lowvalue[bit];
	327	fHighSDDValue[bit]= highvalue[bit];
	328	}
	329
3647765c	330	}
80b9610c	331
80b9610c	332