[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 <TH1D.h>
#include <TH2.h>
// --- AliRoot header files ---
#include "AliITSQADataMakerRec.h"
#include "AliITSQASDDChecker.h"
#include "AliLog.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.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() 
{

  //destructor
  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, const TObjArray * list, const AliDetectorRecoParam * /*recoparam*/) 
{
  //check histograms of the different lists  
  AliInfo(Form("AliITSQASDDChecker called with offset: %d\n", fSubDetOffset) );

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

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

  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;
	SDDQACheckerValue= fHighSDDValue[AliQAv1::kWARNING];
      }
    fCalibration = (TObjArray *)calibSDD->GetObject();
    
    if(!cacheStatus)calibSDD->SetObject(NULL);
    calibSDD->SetOwner(kTRUE);
    if(!cacheStatus)
      {
	delete calibSDD;
      }
  }

  AliInfo("Calib SDD Created\n ");

  TIter next(list);
  TH1 *hmodule=NULL;
  TH2 *hlayer[2];

  switch(index) 
    {

    case AliQAv1::kRAW:
      AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
      if(fRawModulePattern) { delete fRawModulePattern; fRawModulePattern = 0; }
      if(fRawL3Pattern) { delete fRawL3Pattern; fRawL3Pattern = 0; }
      if(fRawL4Pattern) { delete fRawL4Pattern; fRawL4Pattern = 0; }
      if (list->GetEntries() == 0){ 
	SDDQACheckerValue += fHighSDDValue[AliQAv1::kFATAL];
	break;
      }
      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;
      }
      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")){
	    if(hname.Contains("NORM")) {
					
	      hmodule=hdata;
	      entries= hdata->GetEntries();
	      if(AliITSQADataMakerRec::AreEqual(entries,0.)){
		AliWarning(Form("===================>>>>>> No entries in  %s \n",hname.Data()));
		SDDQACheckerValue += 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(AliITSQADataMakerRec::AreEqual(content,0.)) empty++;
		  else filled++;
		}//end for
		AliInfo(Form(" %s : empty modules %i \t filled modules %i",hname.Data(), empty, filled));
	      }//end else pattern entries !=0
	    } 
	  }

	  if(hname.Contains("_RelativeOccupancy")) {
	    fRawModulePattern = (TH1F *) hdata;
	    Float_t threshold = fRawModulePattern->GetMean() + 4*fRawModulePattern->GetRMS();
	    if(hname.Contains("L3")) AliInfo(Form("SDD check number 1: L3 mean: %f, rms: ,%f",fRawModulePattern->GetMean(),fRawModulePattern->GetRMS()));
	    if(hname.Contains("L4")) AliInfo(Form("SDD check number 2: L4 mean: %f, rms: ,%f",fRawModulePattern->GetMean(),fRawModulePattern->GetRMS()));
	    Int_t aboveThreshold = 0;
	    for(Int_t k=0; k<= fRawModulePattern->GetNbinsX(); k++) {
	      if(fRawModulePattern->GetBinLowEdge(k) > threshold) aboveThreshold += (int)(fRawModulePattern->GetBinContent(k));
	    }
	    Float_t fractionAboveThreshold = ((Float_t) aboveThreshold)/fRawModulePattern->GetEntries();
	    if(hname.Contains("L3")) AliInfo(Form("SDD check number 1, L3: Raw fractionAboveThreshold: %f",fractionAboveThreshold));
	    if(hname.Contains("L4")) AliInfo(Form("SDD check number 2, L4: Raw fractionAboveThreshold: %f",fractionAboveThreshold));
	    if(fractionAboveThreshold > fThresholdForRelativeOccupancy) { 
	      SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
	      if(hname.Contains("L3")) AliInfo(Form("SDD check number 1: Set Warning (L3 Raw)"));
	      if(hname.Contains("L4")) AliInfo(Form("SDD check number 2: Set Warning (L4 Raw)"));
	    }
	  }
					
	  if(hname.Contains("SDDphizL3") || hname.Contains("SDDphizL4")){
	    if(!hname.Contains("NORM")) {
	      if(hname.Contains("L3")) {
		fRawL3Pattern = (TH2F *) hdata;
	      }
	      if(hname.Contains("L4")) {
		fRawL4Pattern = (TH2F *) hdata;
	      }
	    } else{
	      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()));
		SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];
		if(AliITSQADataMakerRec::AreEqual(entries,0.)){ 
		}
	      }//end if getentries
	      else{
		Int_t layer1=0;
		if(hname.Contains("3"))layer1=0;
		else  if(hname.Contains("4"))layer1=1;
		TH2* htemp=dynamic_cast<TH2*>(hdata);
		hlayer[layer1]=(TH2*)htemp->Clone();
		char newname[50];
		sprintf(newname,"%s_copy",hname.Data());
		hlayer[layer1]->SetName(newname);
		hlayer[layer1]->RebinX(2);
		int modmay=hlayer[layer1]->GetNbinsY();
		TH1D* hproj= hlayer[layer1]->ProjectionY();
		Double_t ladcontent=0;
		for(Int_t i=1;i<=modmay;i++) {//loop on the ladders
		  ladcontent=hproj->GetBinContent(i);
		  if(AliITSQADataMakerRec::AreEqual(ladcontent,0.)) emptyladders[layer1]++;
		  else filledladders[layer1]++; 
		}//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 check on norm	      
	  }//end if layer 3
	}//end if hdata	
      }//end while
      if(AliITSQADataMakerRec::AreEqual(entries,0.)&&AliITSQADataMakerRec::AreEqual(entries2[0],0.)&&AliITSQADataMakerRec::AreEqual(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
	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(AliITSQADataMakerRec::AreEqual(content,0.)== kFALSE || AliITSQADataMakerRec::AreEqual(contentlayer[lay-3],0.)==kFALSE) {
	      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(AliITSQADataMakerRec::AreEqual(content,0.) && AliITSQADataMakerRec::AreEqual(contentlayer[lay-3],0.)) 
	      emptymodules[lay-3]++;
	  } else {
	    Double_t contentgood=0.;
	    active++;
	    contentgood=hlayer[lay-3]->GetBinContent(det,lad);
	    if(AliITSQADataMakerRec::AreEqual(contentgood,0.)) 
	      emptymodules[lay-3]++;
	    else 
	      filledmodules[lay-3]++;
	  }
	}//end for
	for(Int_t i=0;i<2;i++){AliInfo(Form("Layer %i \tempty modules %i \t filled modules %i\n", 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));
	  SDDQACheckerValue=fHighSDDValue[AliQAv1::kINFO];
	}
	if(exactive!=0){
	  AliWarning(Form("%i modules excluded from the acquisition took data. Active modules%i \n ",exactive,active));
	  SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
	}
	if(excluded==exactive){
	  AliWarning(Form("All the modules excluded from the acquisition (%d) took data!  Active modules %i\n",excluded,active));
	  SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
	}
	if(active==0){
	  AliWarning(Form("No modules took data: excluded %i \t exactive %i \n", excluded, exactive)); 
	  SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
	}
	for(Int_t i=0;i<2;i++) {
	  delete hlayer[i];
	  hlayer[i]=NULL;
	}
      }//end else 
      //}
      
      break;

    case AliQAv1::kNULLTASK:
      AliInfo(Form("No Check on %s\n",AliQAv1::GetAliTaskName(index))); 
      SDDQACheckerValue=1.;
      break;
		
    case AliQAv1::kREC:
      AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index))); 
      if(fRecModulePattern) { delete fRecModulePattern; fRecModulePattern = 0; }
      if(fRecL3Pattern) { delete fRecL3Pattern; fRecL3Pattern = 0; }
      if(fRecL4Pattern) { delete fRecL4Pattern; fRecL4Pattern = 0; }
      if(fModulePatternRatio) { delete fModulePatternRatio; fModulePatternRatio = 0; }
      if (list->GetEntries() == 0){ //check if the list is empty
	//printf("SDDQACheckerValue = %f \t value %f\n",SDDQACheckerValue,fHighSDDValue[AliQAv1::kFATAL]);
	SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
				
      }//end if getentries
	  
      while((hdata=dynamic_cast<TH1* >(next()))){
	if (hdata){
	  TString hname=hdata->GetName();
	  if(hname.Contains("_RelativeOccupancy")) {
	    fRecModulePattern = (TH1F *) hdata;
	    Float_t threshold = fRecModulePattern->GetMean() + 4*fRecModulePattern->GetRMS();
	    if(hname.Contains("L3")) AliInfo(Form("SDD check number 3: L3 mean: %f, rms: ,%f",fRecModulePattern->GetMean(),fRecModulePattern->GetRMS()));
	    if(hname.Contains("L4")) AliInfo(Form("SDD check number 4: L4 mean: %f, rms: ,%f",fRecModulePattern->GetMean(),fRecModulePattern->GetRMS()));
	    Int_t aboveThreshold = 0;
	    for(Int_t k=0; k<= ((Int_t)fRecModulePattern->GetNbinsX()); k++) {
	      if(fRecModulePattern->GetBinLowEdge(k) > threshold) aboveThreshold += (Int_t)(fRecModulePattern->GetBinContent(k));
	    }
	    Float_t fractionAboveThreshold = ((Float_t) aboveThreshold)/fRecModulePattern->GetEntries();
	    if(hname.Contains("L3")) AliInfo(Form("SDD check number 3, L3: RecPoints fractionAboveThreshold: %f",fractionAboveThreshold));
	    if(hname.Contains("L4")) AliInfo(Form("SDD check number 4, L4: RecPoints fractionAboveThreshold: %f",fractionAboveThreshold));
	    if(fractionAboveThreshold > fThresholdForRelativeOccupancy) { 
	      SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
	      if(hname.Contains("L3")) AliInfo(Form("SDD check number 3: Set Warning (L3 RecPoints)"));
	      if(hname.Contains("L4")) AliInfo(Form("SDD check number 4: Set Warning (L4 RecPoints)"));
	    }
	  }
	  if(hname.Contains("Rec2Raw") && !hname.Contains("2D")) {
	    //Float_t threshold = 0.;
	    if(hname.Contains("L3")) AliInfo(Form("SDD check number 5: L3 R2R mean: %f, rms: ,%f",((TH1F *) hdata)->GetMean(),((TH1F *) hdata)->GetRMS()));
	    if(hname.Contains("L4")) AliInfo(Form("SDD check number 6: L4 R2R mean: %f, rms: ,%f",((TH1F *) hdata)->GetMean(),((TH1F *) hdata)->GetRMS()));
	    Int_t belowThreshold = 0;
	    for(Int_t k=0; k<=((TH1F *)hdata)->GetNbinsX(); k++) {
	      if(((TH1F *) hdata)->GetBinLowEdge(k) < fThresholdForRecToRawRatio) belowThreshold += ((Int_t)((TH1F *) hdata)->GetBinContent(k));
	    }
	    Double_t fractionBelowThreshold =0.;
	    Double_t entries=((TH1F *)hdata)->GetEntries();
	    if(entries!=0.)fractionBelowThreshold = ((Double_t)(belowThreshold))/entries;
	    else{ AliWarning(Form("No entries on %s. The check will retuns zero.\n",hdata->GetName() )); }
	    if(hname.Contains("L3")) AliInfo(Form("SDD check number 5, L3: RecPoints2Raws fractionBelowThreshold: %f",fractionBelowThreshold));
	    if(hname.Contains("L4")) AliInfo(Form("SDD check number 6, L4: RecPoints2Raws fractionBelowThreshold: %f",fractionBelowThreshold));
	    if(fractionBelowThreshold > fThresholdForRelativeOccupancy) { 
	      SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
	      if(hname.Contains("L3")) AliInfo(Form("SDD check number 5: Set Warning (L3 RecPoints2Raws)"));
	      if(hname.Contains("L4")) AliInfo(Form("SDD check number 6: Set Warning (L4 RecPoints2Raws)"));
	    }
	  }
	  if(hname.Contains("dedx")) {
	    if(hname.Contains("L3")) AliInfo(Form("SDD check number 7: L3 average charge: %f, rms: ,%f",hdata->GetMean(),hdata->GetRMS()));
	    if(hname.Contains("L4")) AliInfo(Form("SDD check number 8: L4 average charge: %f, rms: ,%f",hdata->GetMean(),hdata->GetRMS()));
	  }
	}
      }				
			       
      SDDQACheckerValue=1.;
      break;
    case AliQAv1::kANA:
      AliInfo(Form("===================> No Check on %s\n",AliQAv1::GetAliTaskName(index)));
      SDDQACheckerValue=1.; 
      break;
    case AliQAv1::kESD:
      AliInfo(Form("==================>  No Check on %s\n",AliQAv1::GetAliTaskName(index)));
      SDDQACheckerValue=1.; 
      break;
    case AliQAv1::kNTASK:
      AliInfo(Form("==================>  No Check on %s\n",AliQAv1::GetAliTaskName(index))); 
      SDDQACheckerValue=1.;
      break;
    case AliQAv1::kSIM:
      AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index))); 
      Int_t uid=list->GetUniqueID();
      if(uid==60) {
	//digits
	if (list->GetEntries() == 0){ 
	  SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
	    
	} else{
	    
	  while( (hdata = dynamic_cast<TH1* >(next())) ){
	    if (hdata){
	      if(hdata->GetEntries()==0)SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];
	      else {
		TString hname=hdata->GetName();
		if(hname.Contains("SDDDIGITSModulePattern")) {
		  //see raws

		  SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
		} else if(hname.Contains("SDDAnodeDistribution")) {
		  SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
		} else if(hname.Contains("SDDTbinDistribution")) {
		  //to do as rp
		  SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
		} else if(hname.Contains("SDDADCCountsDistribution")) {
		  SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
		}//end adc counts

	      }//end entries !=0
	    }//end hdata
	  }//end while
	}//end else
      } else if(uid==50) 
	{
	  //hits
	  if (list->GetEntries() == 0){ 
	    SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
	  } 
	  else{
	    
	    while( (hdata = dynamic_cast<TH1* >(next())) ){
	      if (hdata){
		if(hdata->GetEntries()==0)SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];
		else {
		  TString hname=hdata->GetName();
		  if(hname.Contains("SDDHITSModulePattern")) {
		    //to do as raws
		    SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
		  } else if(hname.Contains("SDDHITlenghtalonglocalYCoord")) {
		    SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
		  } else if(hname.Contains("SDDHITlenghtalonglocalYCoordZoom")) {
		    SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
		  } else if(hname.Contains("SDDDepositedEnergyDistribution")) {
		    SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
		  }//end deposited energy

		}//end entries !=0
	      }//end hdata
	    }//end while
	  }//end else
	} else if(uid==70) 
	{
	  //sdigits
	  if (list->GetEntries() == 0){ 
	    SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
	  } else{
	    
	    while( (hdata = dynamic_cast<TH1* >(next())) ){
	      if (hdata){
		if(hdata->GetEntries()==0)SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];
		else {
		  TString hname=hdata->GetName();
		  if(hname.Contains("SDDSDIGITSModulePattern")) {
		    //to do as raws
		    SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
		  } else if(hname.Contains("SDDAnodeDistribution")) {
		    SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
		  } else if(hname.Contains("SDDTbinDistribution")) {
		    //to do as rp
		    SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
		  } else if(hname.Contains("SDDADCCountsDistribution")) {
		    SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
		  }//end adc counts bindistribution
		}//end entries !=0
	      }//end hdata
	    }//end while
	  }//end else
	}//end sdigits
      SDDQACheckerValue=1.;
      break;
      
    }//end switch

  fCalibration=NULL;
  delete hdata;
  return SDDQACheckerValue;	
}
 
//__________________________________________________________________
void AliITSQASDDChecker::SetTaskOffset(Int_t taskoffset)
{
  //set the number of the histograms already present in the list before the SDD histograms
  fSubDetOffset = taskoffset;
}


//__________________________________________________________________
void AliITSQASDDChecker::SetStepBit(const Double_t *steprange)
{
  //set the values of the step bit for each QA bit range calculated in the AliITSQAChecker class
  fStepBitSDD = new Double_t[AliQAv1::kNBIT];
  for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
    {
      fStepBitSDD[bit]=steprange[bit];
    }
}

//__________________________________________________________________
void  AliITSQASDDChecker::SetSDDLimits(const Float_t *lowvalue, const Float_t * highvalue)
{
  //set the low and high values in for each QA bit range calculated in the AliITSQAChecker class
  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
5b716935	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
	21	// P. Cerello Apr 2008
	22	// INFN Torino
	23
	24	// --- ROOT system ---
3647765c	25	#include "TH1.h"
80b9610c	26	#include <TH1D.h>
80b9610c	27	#include <TH2.h>
5b716935	28	// --- AliRoot header files ---
f09c0b42	29	#include "AliITSQADataMakerRec.h"
5b716935	30	#include "AliITSQASDDChecker.h"
c71529b0	31	#include "AliLog.h"
3647765c	32	#include "AliCDBEntry.h"
f09c0b42	33	#include "AliCDBManager.h"
80b9610c	34	#include "AliITSCalibrationSDD.h"
80b9610c	35	#include "AliITSgeomTGeo.h"
f09c0b42	36
5b716935	37
3647765c	38	ClassImp(AliITSQASDDChecker)
5b716935	39	//__________________________________________________________________
	40	AliITSQASDDChecker& AliITSQASDDChecker::operator = (const AliITSQASDDChecker& qac )
	41	{
	42	// Equal operator.
	43	this->~AliITSQASDDChecker();
	44	new(this) AliITSQASDDChecker(qac);
	45	return *this;
	46	}
	47
80b9610c	48	AliITSQASDDChecker::~AliITSQASDDChecker()
80b9610c	49	{
f09c0b42	50
f09c0b42	51	//destructor
80b9610c	52	if(fStepBitSDD)
	53	{
	54	delete[] fStepBitSDD ;
	55	fStepBitSDD = NULL;
	56	}
	57	if(fLowSDDValue)
	58	{
	59	delete[]fLowSDDValue;
	60	fLowSDDValue=NULL;
	61	}
	62	if(fHighSDDValue)
	63	{
	64	delete[]fHighSDDValue;
	65	fHighSDDValue=NULL;
	66	}
	67	if(fCalibration)
	68	{
	69	delete fCalibration;
	70	fCalibration=NULL;
	71	}
	72	} // dtor
	73
5b716935	74	//__________________________________________________________________
f09c0b42	75	Double_t AliITSQASDDChecker::Check(AliQAv1::ALITASK_t index, const TObjArray * list, const AliDetectorRecoParam * /recoparam/)
	76	{
	77	//check histograms of the different lists
80b9610c	78	AliInfo(Form("AliITSQASDDChecker called with offset: %d\n", fSubDetOffset) );
80b9610c	79
3647765c	80	AliDebug(1,Form("AliITSQASDDChecker called with offset: %d\n", fSubDetOffset));
3647765c	81
78fb0b3d	82	Double_t SDDQACheckerValue = 0.;
80b9610c	83	TH1 *hdata=NULL;
	84	Double_t entries=0.;
	85	Double_t entries2[2];
	86	for(Int_t i=0;i<2;i++)entries2[i]=0.;
80118b05	87
	88	if(!fCalibration){
	89	AliCDBEntry *calibSDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD");
	90	Bool_t cacheStatus = AliCDBManager::Instance()->GetCacheFlag();
	91	if(!calibSDD)
	92	{
	93	AliError("Calibration object retrieval failed! SDD will not be processed");
	94	fCalibration = NULL;
78fb0b3d	95	SDDQACheckerValue= fHighSDDValue[AliQAv1::kWARNING];
80118b05	96	}
	97	fCalibration = (TObjArray *)calibSDD->GetObject();
	98
	99	if(!cacheStatus)calibSDD->SetObject(NULL);
	100	calibSDD->SetOwner(kTRUE);
	101	if(!cacheStatus)
	102	{
	103	delete calibSDD;
	104	}
	105	}
	106
78fb0b3d	107	AliInfo("Calib SDD Created\n ");
80118b05	108
78fb0b3d	109	TIter next(list);
	110	TH1 *hmodule=NULL;
	111	TH2 *hlayer[2];
	112
	113	switch(index)
80b9610c	114	{
3647765c	115
80b9610c	116	case AliQAv1::kRAW:
80b9610c	117	AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
78fb0b3d	118	if(fRawModulePattern) { delete fRawModulePattern; fRawModulePattern = 0; }
	119	if(fRawL3Pattern) { delete fRawL3Pattern; fRawL3Pattern = 0; }
	120	if(fRawL4Pattern) { delete fRawL4Pattern; fRawL4Pattern = 0; }
	121	if (list->GetEntries() == 0){
	122	SDDQACheckerValue += fHighSDDValue[AliQAv1::kFATAL];
80b9610c	123	break;
78fb0b3d	124	}
	125	Int_t emptymodules[2];
	126	Int_t filledmodules[2];
	127	Int_t emptyladders[2];
	128	Int_t filledladders[2];
	129	for(Int_t i=0;i<2;i++){
	130	emptymodules[i]=0;
	131	filledmodules[i]=0;
	132	emptyladders[i]=0;
	133	filledladders[i]=0;
	134	}
	135	for(Int_t i=0;i<2;i++)hlayer[i]=NULL;
	136	while( (hdata = dynamic_cast<TH1* >(next())) ){
	137	if (hdata){
	138	TString hname=hdata->GetName();
	139	if(hname.Contains("SDDchargeMap"))continue;
	140	if(hname.Contains("SDDModPattern")){
	141	if(hname.Contains("NORM")) {
	142
	143	hmodule=hdata;
	144	entries= hdata->GetEntries();
	145	if(AliITSQADataMakerRec::AreEqual(entries,0.)){
	146	AliWarning(Form("===================>>>>>> No entries in %s \n",hname.Data()));
	147	SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];
	148	}//endif entries
80b9610c	149	else{
78fb0b3d	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(AliITSQADataMakerRec::AreEqual(content,0.)) empty++;
	157	else 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	}
	162	}
	163
	164	if(hname.Contains("_RelativeOccupancy")) {
	165	fRawModulePattern = (TH1F *) hdata;
	166	Float_t threshold = fRawModulePattern->GetMean() + 4*fRawModulePattern->GetRMS();
	167	if(hname.Contains("L3")) AliInfo(Form("SDD check number 1: L3 mean: %f, rms: ,%f",fRawModulePattern->GetMean(),fRawModulePattern->GetRMS()));
	168	if(hname.Contains("L4")) AliInfo(Form("SDD check number 2: L4 mean: %f, rms: ,%f",fRawModulePattern->GetMean(),fRawModulePattern->GetRMS()));
	169	Int_t aboveThreshold = 0;
	170	for(Int_t k=0; k<= fRawModulePattern->GetNbinsX(); k++) {
	171	if(fRawModulePattern->GetBinLowEdge(k) > threshold) aboveThreshold += (int)(fRawModulePattern->GetBinContent(k));
80b9610c	172	}
78fb0b3d	173	Float_t fractionAboveThreshold = ((Float_t) aboveThreshold)/fRawModulePattern->GetEntries();
	174	if(hname.Contains("L3")) AliInfo(Form("SDD check number 1, L3: Raw fractionAboveThreshold: %f",fractionAboveThreshold));
	175	if(hname.Contains("L4")) AliInfo(Form("SDD check number 2, L4: Raw fractionAboveThreshold: %f",fractionAboveThreshold));
	176	if(fractionAboveThreshold > fThresholdForRelativeOccupancy) {
	177	SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
	178	if(hname.Contains("L3")) AliInfo(Form("SDD check number 1: Set Warning (L3 Raw)"));
	179	if(hname.Contains("L4")) AliInfo(Form("SDD check number 2: Set Warning (L4 Raw)"));
80b9610c	180	}
78fb0b3d	181	}
	182
	183	if(hname.Contains("SDDphizL3") \|\| hname.Contains("SDDphizL4")){
	184	if(!hname.Contains("NORM")) {
	185	if(hname.Contains("L3")) {
	186	fRawL3Pattern = (TH2F *) hdata;
80118b05	187	}
78fb0b3d	188	if(hname.Contains("L4")) {
	189	fRawL4Pattern = (TH2F *) hdata;
	190	}
	191	} else{
	192	Int_t layer=0;
	193	if(hname.Contains("3"))layer=0;
	194	else if(hname.Contains("4"))layer=1;
	195	entries2[layer]=hdata->GetEntries();
	196	if(entries2[layer]==0){
	197	AliWarning(Form("===================>>>>>> No entries in %s \n",hname.Data()));
	198	SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];
	199	if(AliITSQADataMakerRec::AreEqual(entries,0.)){
	200	}
	201	}//end if getentries
	202	else{
	203	Int_t layer1=0;
	204	if(hname.Contains("3"))layer1=0;
	205	else if(hname.Contains("4"))layer1=1;
	206	TH2* htemp=dynamic_cast<TH2*>(hdata);
	207	hlayer[layer1]=(TH2*)htemp->Clone();
	208	char newname[50];
	209	sprintf(newname,"%s_copy",hname.Data());
	210	hlayer[layer1]->SetName(newname);
	211	hlayer[layer1]->RebinX(2);
	212	int modmay=hlayer[layer1]->GetNbinsY();
	213	TH1D* hproj= hlayer[layer1]->ProjectionY();
	214	Double_t ladcontent=0;
	215	for(Int_t i=1;i<=modmay;i++) {//loop on the ladders
	216	ladcontent=hproj->GetBinContent(i);
	217	if(AliITSQADataMakerRec::AreEqual(ladcontent,0.)) emptyladders[layer1]++;
	218	else filledladders[layer1]++;
	219	}//end for
	220	AliInfo(Form(" %s : empty ladders %i \t filled ladders %i\n",hname.Data(), emptyladders[layer], filledladders[layer]));//end else layer 3
	221	delete hproj;
	222	hproj=NULL;
	223	}//end else entries !=0
	224	}//end check on norm
	225	}//end if layer 3
	226	}//end if hdata
	227	}//end while
	228	if(AliITSQADataMakerRec::AreEqual(entries,0.)&&AliITSQADataMakerRec::AreEqual(entries2[0],0.)&&AliITSQADataMakerRec::AreEqual(entries2[1],0.)) break;
	229	//else{
	230	if(hmodule \|\| (hlayer[0] && hlayer[1])){
	231	Int_t excluded=0;
	232	Int_t active=0;
	233	Int_t exactive=0;//excluded but taking data
	234	for(Int_t imod=0;imod<fgknSDDmodules;imod++){
	235	Int_t lay=0;
	236	Int_t lad=0;
	237	Int_t det=0;
	238	Int_t module=0;
	239	module=imod+fgkmodoffset;
	240	AliITSCalibrationSDD * cal=(AliITSCalibrationSDD*)fCalibration->At(imod);
	241	if(cal==0) { delete cal; continue;}
	242	AliITSgeomTGeo::GetModuleId(module,lay,lad,det);
	243	if (cal->IsBad()){
	244	excluded++;
	245	Double_t content=0.;
	246	Double_t contentlayer[2];
	247	for(Int_t i=0;i<2;i++)contentlayer[i]=0.;
	248	if(hmodule)content=hmodule->GetBinContent(imod+1);//if expert bit is active the histogram has been created
	249	contentlayer[lay-3]=hlayer[lay-3]->GetBinContent(det,lad);
	250	if(AliITSQADataMakerRec::AreEqual(content,0.)== kFALSE \|\| AliITSQADataMakerRec::AreEqual(contentlayer[lay-3],0.)==kFALSE) {
	251	filledmodules[lay-3]++;
252	AliWarning(Form("The module %d (layer %i, ladder %i det %i ) excluded from the acquisition, took data \n ",module,lay,lad,det));
253	exactive++;
254	} else if(AliITSQADataMakerRec::AreEqual(content,0.) && AliITSQADataMakerRec::AreEqual(contentlayer[lay-3],0.))
255	emptymodules[lay-3]++;
256	} else {
257	Double_t contentgood=0.;
258	active++;
259	contentgood=hlayer[lay-3]->GetBinContent(det,lad);
260	if(AliITSQADataMakerRec::AreEqual(contentgood,0.))
261	emptymodules[lay-3]++;
262	else
263	filledmodules[lay-3]++;
264	}
265	}//end for
266	for(Int_t i=0;i<2;i++){AliInfo(Form("Layer %i \tempty modules %i \t filled modules %i\n", i+3,emptymodules[i], filledmodules[i]));}//end else layers
267	if(exactive==0){
268	AliInfo(Form("All the active modules (%i) are in acquisition. The number of excluded modules are %i \n",active,excluded));
269	SDDQACheckerValue=fHighSDDValue[AliQAv1::kINFO];
3647765c	270	}
78fb0b3d	271	if(exactive!=0){
	272	AliWarning(Form("%i modules excluded from the acquisition took data. Active modules%i \n ",exactive,active));
	273	SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
	274	}
	275	if(excluded==exactive){
	276	AliWarning(Form("All the modules excluded from the acquisition (%d) took data! Active modules %i\n",excluded,active));
	277	SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
	278	}
	279	if(active==0){
	280	AliWarning(Form("No modules took data: excluded %i \t exactive %i \n", excluded, exactive));
	281	SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
	282	}
	283	for(Int_t i=0;i<2;i++) {
	284	delete hlayer[i];
	285	hlayer[i]=NULL;
	286	}
	287	}//end else
	288	//}
80b9610c	289
80b9610c	290	break;
78fb0b3d	291
80b9610c	292	case AliQAv1::kNULLTASK:
80b9610c	293	AliInfo(Form("No Check on %s\n",AliQAv1::GetAliTaskName(index)));
78fb0b3d	294	SDDQACheckerValue=1.;
80b9610c	295	break;
78fb0b3d	296
80b9610c	297	case AliQAv1::kREC:
80b9610c	298	AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
78fb0b3d	299	if(fRecModulePattern) { delete fRecModulePattern; fRecModulePattern = 0; }
	300	if(fRecL3Pattern) { delete fRecL3Pattern; fRecL3Pattern = 0; }
	301	if(fRecL4Pattern) { delete fRecL4Pattern; fRecL4Pattern = 0; }
	302	if(fModulePatternRatio) { delete fModulePatternRatio; fModulePatternRatio = 0; }
	303	if (list->GetEntries() == 0){ //check if the list is empty
	304	//printf("SDDQACheckerValue = %f \t value %f\n",SDDQACheckerValue,fHighSDDValue[AliQAv1::kFATAL]);
	305	SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
	306
	307	}//end if getentries
80118b05	308
78fb0b3d	309	while((hdata=dynamic_cast<TH1* >(next()))){
	310	if (hdata){
	311	TString hname=hdata->GetName();
	312	if(hname.Contains("_RelativeOccupancy")) {
	313	fRecModulePattern = (TH1F *) hdata;
	314	Float_t threshold = fRecModulePattern->GetMean() + 4*fRecModulePattern->GetRMS();
	315	if(hname.Contains("L3")) AliInfo(Form("SDD check number 3: L3 mean: %f, rms: ,%f",fRecModulePattern->GetMean(),fRecModulePattern->GetRMS()));
	316	if(hname.Contains("L4")) AliInfo(Form("SDD check number 4: L4 mean: %f, rms: ,%f",fRecModulePattern->GetMean(),fRecModulePattern->GetRMS()));
	317	Int_t aboveThreshold = 0;
	318	for(Int_t k=0; k<= ((Int_t)fRecModulePattern->GetNbinsX()); k++) {
	319	if(fRecModulePattern->GetBinLowEdge(k) > threshold) aboveThreshold += (Int_t)(fRecModulePattern->GetBinContent(k));
	320	}
	321	Float_t fractionAboveThreshold = ((Float_t) aboveThreshold)/fRecModulePattern->GetEntries();
	322	if(hname.Contains("L3")) AliInfo(Form("SDD check number 3, L3: RecPoints fractionAboveThreshold: %f",fractionAboveThreshold));
	323	if(hname.Contains("L4")) AliInfo(Form("SDD check number 4, L4: RecPoints fractionAboveThreshold: %f",fractionAboveThreshold));
	324	if(fractionAboveThreshold > fThresholdForRelativeOccupancy) {
	325	SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
	326	if(hname.Contains("L3")) AliInfo(Form("SDD check number 3: Set Warning (L3 RecPoints)"));
	327	if(hname.Contains("L4")) AliInfo(Form("SDD check number 4: Set Warning (L4 RecPoints)"));
	328	}
	329	}
	330	if(hname.Contains("Rec2Raw") && !hname.Contains("2D")) {
	331	//Float_t threshold = 0.;
	332	if(hname.Contains("L3")) AliInfo(Form("SDD check number 5: L3 R2R mean: %f, rms: ,%f",((TH1F ) hdata)->GetMean(),((TH1F ) hdata)->GetRMS()));
	333	if(hname.Contains("L4")) AliInfo(Form("SDD check number 6: L4 R2R mean: %f, rms: ,%f",((TH1F ) hdata)->GetMean(),((TH1F ) hdata)->GetRMS()));
	334	Int_t belowThreshold = 0;
	335	for(Int_t k=0; k<=((TH1F *)hdata)->GetNbinsX(); k++) {
	336	if(((TH1F ) hdata)->GetBinLowEdge(k) < fThresholdForRecToRawRatio) belowThreshold += ((Int_t)((TH1F ) hdata)->GetBinContent(k));
	337	}
	338	Double_t fractionBelowThreshold =0.;
	339	Double_t entries=((TH1F *)hdata)->GetEntries();
	340	if(entries!=0.)fractionBelowThreshold = ((Double_t)(belowThreshold))/entries;
	341	else{ AliWarning(Form("No entries on %s. The check will retuns zero.\n",hdata->GetName() )); }
	342	if(hname.Contains("L3")) AliInfo(Form("SDD check number 5, L3: RecPoints2Raws fractionBelowThreshold: %f",fractionBelowThreshold));
	343	if(hname.Contains("L4")) AliInfo(Form("SDD check number 6, L4: RecPoints2Raws fractionBelowThreshold: %f",fractionBelowThreshold));
	344	if(fractionBelowThreshold > fThresholdForRelativeOccupancy) {
	345	SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
	346	if(hname.Contains("L3")) AliInfo(Form("SDD check number 5: Set Warning (L3 RecPoints2Raws)"));
	347	if(hname.Contains("L4")) AliInfo(Form("SDD check number 6: Set Warning (L4 RecPoints2Raws)"));
	348	}
	349	}
	350	if(hname.Contains("dedx")) {
	351	if(hname.Contains("L3")) AliInfo(Form("SDD check number 7: L3 average charge: %f, rms: ,%f",hdata->GetMean(),hdata->GetRMS()));
	352	if(hname.Contains("L4")) AliInfo(Form("SDD check number 8: L4 average charge: %f, rms: ,%f",hdata->GetMean(),hdata->GetRMS()));
	353	}
	354	}
	355	}
	356
	357	SDDQACheckerValue=1.;
80b9610c	358	break;
80b9610c	359	case AliQAv1::kANA:
80118b05	360	AliInfo(Form("===================> No Check on %s\n",AliQAv1::GetAliTaskName(index)));
78fb0b3d	361	SDDQACheckerValue=1.;
80b9610c	362	break;
80b9610c	363	case AliQAv1::kESD:
80118b05	364	AliInfo(Form("==================> No Check on %s\n",AliQAv1::GetAliTaskName(index)));
78fb0b3d	365	SDDQACheckerValue=1.;
80b9610c	366	break;
80b9610c	367	case AliQAv1::kNTASK:
80118b05	368	AliInfo(Form("==================> No Check on %s\n",AliQAv1::GetAliTaskName(index)));
78fb0b3d	369	SDDQACheckerValue=1.;
80118b05	370	break;
	371	case AliQAv1::kSIM:
	372	AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
	373	Int_t uid=list->GetUniqueID();
78fb0b3d	374	if(uid==60) {
	375	//digits
	376	if (list->GetEntries() == 0){
	377	SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
80118b05	378
78fb0b3d	379	} else{
80118b05	380
78fb0b3d	381	while( (hdata = dynamic_cast<TH1* >(next())) ){
	382	if (hdata){
	383	if(hdata->GetEntries()==0)SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];
	384	else {
	385	TString hname=hdata->GetName();
	386	if(hname.Contains("SDDDIGITSModulePattern")) {
	387	//see raws
80118b05	388
78fb0b3d	389	SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];
	390	} else if(hname.Contains("SDDAnodeDistribution")) {
	391	SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];
	392	} else if(hname.Contains("SDDTbinDistribution")) {
	393	//to do as rp
	394	SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];
	395	} else if(hname.Contains("SDDADCCountsDistribution")) {
	396	SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];
	397	}//end adc counts
80118b05	398
78fb0b3d	399	}//end entries !=0
	400	}//end hdata
	401	}//end while
	402	}//end else
	403	} else if(uid==50)
80118b05	404	{
80118b05	405	//hits
78fb0b3d	406	if (list->GetEntries() == 0){
	407	SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
	408	}
80118b05	409	else{
80118b05	410
ef0526f3	411	while( (hdata = dynamic_cast<TH1* >(next())) ){
80118b05	412	if (hdata){
78fb0b3d	413	if(hdata->GetEntries()==0)SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];
	414	else {
	415	TString hname=hdata->GetName();
	416	if(hname.Contains("SDDHITSModulePattern")) {
	417	//to do as raws
	418	SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];
	419	} else if(hname.Contains("SDDHITlenghtalonglocalYCoord")) {
	420	SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];
	421	} else if(hname.Contains("SDDHITlenghtalonglocalYCoordZoom")) {
	422	SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];
	423	} else if(hname.Contains("SDDDepositedEnergyDistribution")) {
	424	SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];
	425	}//end deposited energy
80118b05	426
78fb0b3d	427	}//end entries !=0
80118b05	428	}//end hdata
	429	}//end while
	430	}//end else
78fb0b3d	431	} else if(uid==70)
80118b05	432	{
80118b05	433	//sdigits
78fb0b3d	434	if (list->GetEntries() == 0){
	435	SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
	436	} else{
80118b05	437
ef0526f3	438	while( (hdata = dynamic_cast<TH1* >(next())) ){
80118b05	439	if (hdata){
78fb0b3d	440	if(hdata->GetEntries()==0)SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];
	441	else {
	442	TString hname=hdata->GetName();
	443	if(hname.Contains("SDDSDIGITSModulePattern")) {
	444	//to do as raws
	445	SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];
	446	} else if(hname.Contains("SDDAnodeDistribution")) {
	447	SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];
	448	} else if(hname.Contains("SDDTbinDistribution")) {
	449	//to do as rp
	450	SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];
	451	} else if(hname.Contains("SDDADCCountsDistribution")) {
	452	SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];
	453	}//end adc counts bindistribution
	454	}//end entries !=0
80118b05	455	}//end hdata
	456	}//end while
	457	}//end else
	458	}//end sdigits
78fb0b3d	459	SDDQACheckerValue=1.;
80b9610c	460	break;
	461
	462	}//end switch
80118b05	463
80118b05	464	fCalibration=NULL;
80b9610c	465	delete hdata;
78fb0b3d	466	return SDDQACheckerValue;
5b716935	467	}
5b716935	468
3647765c	469	//__________________________________________________________________
80b9610c	470	void AliITSQASDDChecker::SetTaskOffset(Int_t taskoffset)
80b9610c	471	{
f09c0b42	472	//set the number of the histograms already present in the list before the SDD histograms
80b9610c	473	fSubDetOffset = taskoffset;
	474	}
	475
	476
	477	//__________________________________________________________________
f09c0b42	478	void AliITSQASDDChecker::SetStepBit(const Double_t *steprange)
80b9610c	479	{
f09c0b42	480	//set the values of the step bit for each QA bit range calculated in the AliITSQAChecker class
80b9610c	481	fStepBitSDD = new Double_t[AliQAv1::kNBIT];
	482	for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
	483	{
	484	fStepBitSDD[bit]=steprange[bit];
	485	}
	486	}
	487
	488	//__________________________________________________________________
f09c0b42	489	void AliITSQASDDChecker::SetSDDLimits(const Float_t lowvalue, const Float_t highvalue)
3647765c	490	{
f09c0b42	491	//set the low and high values in for each QA bit range calculated in the AliITSQAChecker class
80b9610c	492	fLowSDDValue = new Float_t[AliQAv1::kNBIT];
	493	fHighSDDValue= new Float_t[AliQAv1::kNBIT];
	494
	495	for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
	496	{
	497	fLowSDDValue[bit]=lowvalue[bit];
	498	fHighSDDValue[bit]= highvalue[bit];
	499	}
	500
3647765c	501	}
80b9610c	502