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

  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;}
      TH1 *hmodule=NULL;
      TH2 *hlayer[2]; 
      Int_t emptymodules[2], filledmodules[2],emptyladders[2],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")) continue;
	    hmodule=(TH1*)hdata->Clone();
	    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 = hdata->GetMean() + 4*hdata->GetRMS();
	    if(hname.Contains("L3")) AliInfo(Form("SDD check number 1: L3 mean: %f, rms: ,%f",hdata->GetMean(),hdata->GetRMS()));
	    if(hname.Contains("L4")) AliInfo(Form("SDD check number 2: L4 mean: %f, rms: ,%f",hdata->GetMean(),hdata->GetRMS()));
	    Int_t aboveThreshold = 0;
	    for(Int_t k=0; k<= hdata->GetNbinsX(); k++) {if(hdata->GetBinLowEdge(k) > threshold) aboveThreshold += (int)(hdata->GetBinContent(k));}
	    Float_t fractionAboveThreshold = ((Float_t) aboveThreshold)/hdata->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"))continue;
	    //if(hname.Contains("L3")) {fRawL3Pattern = (TH2F *) hdata;}
	    //if(hname.Contains("L4")) {fRawL4Pattern = (TH2F *) hdata;}
	    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];}//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 phiz	      
	}//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 
	    if(hlayer[lay-3]) 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++;
	    if(hlayer[lay-3]) 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];
	}
	
      }//end else 
      delete hmodule;
      hmodule=NULL;
      for(Int_t i=0;i<2;i++) {
	delete hlayer[i];
	hlayer[i]=NULL;
      }

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