#include "TH1.h"
#include <Riostream.h>
#include "TStyle.h"
#include "AliITSQAChecker.h"
#include "AliITSQASPDChecker.h"
#include "AliITSQASDDChecker.h"
#include "AliITSQASSDChecker.h"
#include "AliITSQADataMakerRec.h"
ClassImp(AliITSQAChecker)
AliITSQAChecker::AliITSQAChecker(Bool_t kMode, Short_t subDet, Short_t ldc) :
AliQACheckerBase("ITS","SDD Quality Assurance Checker"),
fkOnline(0),
fDet(0),
fLDC(0),
fSPDOffset(0),
fSDDOffset(0),
fSSDOffset(0),
fSPDHisto(0),
fSDDHisto(0),
fSSDHisto(0),
fSPDChecker(0),
fSDDChecker(0),
fSSDChecker(0)
{
fkOnline = kMode; fDet = subDet; fLDC = ldc;
if(fDet == 0 || fDet == 1) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SPD Checker\n");
fSPDChecker = new AliITSQASPDChecker();
}
if(fDet == 0 || fDet == 2) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SDD Checker\n");
fSDDChecker = new AliITSQASDDChecker();
}
if(fDet == 0 || fDet == 3) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SSD Checker\n");
fSSDChecker = new AliITSQASSDChecker();
}
InitQACheckerLimits();
}
AliITSQAChecker::~AliITSQAChecker(){
if(fSPDChecker)delete fSPDChecker;
if(fSDDChecker)delete fSDDChecker;
if(fSSDChecker)delete fSSDChecker;
}
void AliITSQAChecker::Check(Double_t * rv, AliQAv1::ALITASK_t index, TObjArray ** list, const AliDetectorRecoParam * recoParam)
{
if(index == AliQAv1::kESD){
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
rv[specie] = 0.0 ;
if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
continue ;
AliDebug(AliQAv1::GetQADebugLevel(),"Checker for ESD");
Int_t tested = 0;
Int_t empty = 0;
Bool_t cluMapSA = kFALSE;
Bool_t cluMapMI = kFALSE;
Bool_t cluMI = kFALSE;
Bool_t cluSA = kFALSE;
Bool_t verSPDZ = kFALSE;
if (list[specie]->GetEntries() == 0) {
rv[specie] = 0.;
}
else {
Double_t stepbit[AliQAv1::kNBIT];
Double_t histonumb= list[specie]->GetEntries();
CreateStepForBit(histonumb,stepbit);
TIter next1(list[specie]);
TH1 * hdata;
Int_t nskipped=0;
Bool_t skipped[6]={kFALSE,kFALSE,kFALSE,kFALSE,kFALSE,kFALSE};
while ( (hdata = dynamic_cast<TH1 *>(next1())) ) {
if(hdata){
TString hname = hdata->GetName();
if(!hname.Contains("hESDSkippedLayers")) continue;
for(Int_t k=1; k<7; k++) {
if(hdata->GetBinContent(k)>0) {
nskipped++;
skipped[k-1]=kTRUE;
}
}
}
}
TIter next(list[specie]);
while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
if(hdata){
TString hname = hdata->GetName();
Double_t entries = hdata->GetEntries();
++tested;
if(!(entries>0.))++empty;
AliDebug(AliQAv1::GetQADebugLevel(),Form("ESD hist name %s - entries %12.1g",hname.Data(),entries));
if(hname.Contains("hESDClusterMapSA") && entries>0.){
cluMapSA = kTRUE;
AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
for(Int_t k=1;k<7;k++){
if(skipped[k-1]) continue;
if(hdata->GetBinContent(k)<0.5*(entries/6.)){
cluMapSA = kFALSE;
AliDebug(AliQAv1::GetQADebugLevel(),Form("SA tracks have few points on layer %d - look at histogram hESDClustersSA",k));
}
}
}
else if(hname.Contains("hESDClusterMapMI") && entries>0.){
AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
cluMapMI = kTRUE;
for(Int_t k=1;k<7;k++){
if(skipped[k-1]) continue;
if(hdata->GetBinContent(k)<0.5*(entries/6.)){
cluMapMI = kFALSE;
AliDebug(AliQAv1::GetQADebugLevel(),Form("MI tracks have few points on layer %d - look at histogram hESDClustersMI",k));
}
}
}
else if(hname.Contains("hESDClustersMI") && entries>0.){
AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
cluMI = kTRUE;
Double_t maxlaytracks = hdata->GetBinContent(7-nskipped);
for(Int_t k=2; k<7-nskipped; k++){
if(hdata->GetBinContent(k)>maxlaytracks){
cluMI = kFALSE;
AliDebug(AliQAv1::GetQADebugLevel(),Form("MI Tracks with %d clusters are more than tracks with %d clusters. Look at histogram hESDClustersMI",k-1,6-nskipped));
}
}
}
else if(hname.Contains("hESDClustersSA") && entries>0.){
AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
cluSA = kTRUE;
Double_t maxlaytracks = hdata->GetBinContent(7-nskipped);
for(Int_t k=2; k<7-nskipped; k++){
if(hdata->GetBinContent(k)>maxlaytracks){
cluSA = kFALSE;
AliDebug(AliQAv1::GetQADebugLevel(), Form("SA Tracks with %d clusters are more than tracks with %d clusters. Look at histogram hESDClustersSA",k-1,6-nskipped));
}
}
}
else if(hname.Contains("hSPDVertexZ") && entries>0.){
AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
verSPDZ = kTRUE;
if(hdata->GetMean()<-5. && hdata->GetMean()>5.){
verSPDZ = kFALSE;
AliDebug(AliQAv1::GetQADebugLevel(),Form("Average z vertex coordinate is at z= %10.4g cm",hdata->GetMean()));
}
}
else{ AliError("ESD Checker - invalid data type");}
rv[specie] = 0.;
if(tested>0){
if(tested == empty){
rv[specie] = 2500.;
AliWarning(Form("All ESD histograms are empty - specie=%d",specie));
}
else {
rv[specie] = 2500.-1500.*(static_cast<Double_t>(tested-empty)/static_cast<Double_t>(tested));
if(cluMapSA)rv[specie]-=200.;
if(cluMapMI)rv[specie]-=200.;
if(cluMI)rv[specie]-=200.;
if(cluSA)rv[specie]-=200.;
if(verSPDZ)rv[specie]-=199.;
}
}
}
}
AliInfo(Form("ESD - Tested %d histograms, Return value %f \n",tested,rv[specie]));
}
}
}
else{
Double_t spdCheck[AliRecoParam::kNSpecies] ;
Double_t sddCheck[AliRecoParam::kNSpecies] ;
Double_t ssdCheck[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
if ( !AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
if ( AliQAv1::Instance()->IsEventSpecieSet(specie) ) {
Double_t histotot=list[specie]->GetEntries();
if(histotot!=0)
{
spdCheck[specie]=0.;
sddCheck[specie]=0.;
ssdCheck[specie]=0.;
rv[specie] = 0.0 ;
if(fDet == 0 || fDet == 1) {
fSPDChecker->SetTaskOffset(fSPDOffset);
Double_t histoSPD=double(GetSPDHisto());
if(AliITSQADataMakerRec::AreEqual(histoSPD,0)==kFALSE){
Double_t *stepSPD=new Double_t[AliQAv1::kNBIT];
CreateStepForBit(histoSPD,stepSPD);
fSPDChecker->SetStepBit(stepSPD);
spdCheck[specie] = fSPDChecker->Check(index, list[specie], recoParam);
if(spdCheck[specie]>fUpTestValue[AliQAv1::kFATAL]||spdCheck[specie]<0.)
{
AliInfo(Form("SPD check result for %s is out of range (%f)!!! Retval of specie %s is sit to -1\n ",AliQAv1::GetAliTaskName(index),spdCheck[specie],AliRecoParam::GetEventSpecieName(specie)));
spdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];
}
delete []stepSPD;
}
else{spdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];}
rv[specie]=spdCheck[specie];
}
if(fDet == 0 || fDet == 2) {
fSDDChecker->SetTaskOffset(fSDDOffset);
fSDDChecker->SetEventSpecieForCheck(specie);
Double_t histoSDD=double(GetSDDHisto());
if(AliITSQADataMakerRec::AreEqual(histoSDD,0)==kFALSE){
Double_t *stepSDD=new Double_t[AliQAv1::kNBIT];
CreateStepForBit(histoSDD,stepSDD);
fSDDChecker->SetStepBit(stepSDD);
sddCheck[specie] = fSDDChecker->Check(index, list[specie], recoParam);
if(sddCheck[specie]>fUpTestValue[AliQAv1::kFATAL]||sddCheck[specie]<0.)
{
AliInfo(Form("SDD check result for %s is out of range (%f)!!! Retval of specie %s is sit to -1\n ",AliQAv1::GetAliTaskName(index),sddCheck[specie],AliRecoParam::GetEventSpecieName(specie)));
sddCheck[specie]=fUpTestValue[AliQAv1::kFATAL];
}
delete []stepSDD;
}
else{ssdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];}
if(sddCheck[specie]>rv[specie])rv[specie]=sddCheck[specie];
}
if(fDet == 0 || fDet == 3) {
fSSDChecker->SetTaskOffset(fSSDOffset);
Double_t histoSSD=double(GetSSDHisto());
if(AliITSQADataMakerRec::AreEqual(histoSSD,0)==kFALSE){
Double_t *stepSSD=new Double_t[AliQAv1::kNBIT];
CreateStepForBit(histoSSD,stepSSD);
fSSDChecker->SetStepBit(stepSSD);
ssdCheck[specie] = fSSDChecker->Check(index, list[specie], recoParam);
if(ssdCheck[specie]>fUpTestValue[AliQAv1::kFATAL]||ssdCheck[specie]<0.)
{
AliInfo(Form("SSD check result for %s is out of range (%f)!!! Retval of specie %s is sit to -1\n ",AliQAv1::GetAliTaskName(index),ssdCheck[specie],AliRecoParam::GetEventSpecieName(specie)));
ssdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];
}
delete [] stepSSD;
}
else{ssdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];}
if(ssdCheck[specie]>rv[specie])rv[specie]=ssdCheck[specie];
}
AliInfo(Form("Check result for %s: \n\t SPD %f \n\t SDD %f \n\t SSD %f \n Check result %f \n ",AliQAv1::GetAliTaskName(index),spdCheck[specie],sddCheck[specie],ssdCheck[specie],rv[specie]));
}
}
}
}
}
void AliITSQAChecker::SetTaskOffset(Int_t SPDOffset, Int_t SDDOffset, Int_t SSDOffset)
{
fSPDOffset = SPDOffset;
fSDDOffset = SDDOffset;
fSSDOffset = SSDOffset;
}
void AliITSQAChecker::SetHisto(Int_t SPDhisto, Int_t SDDhisto, Int_t SSDhisto)
{
fSPDHisto = SPDhisto;
fSDDHisto = SDDhisto;
fSSDHisto = SSDhisto;
}
void AliITSQAChecker::SetDetTaskOffset(Int_t subdet,Int_t offset)
{
switch(subdet){
case 1:
SetSPDTaskOffset(offset);
break;
case 2:
SetSDDTaskOffset(offset);
break;
case 3:
SetSSDTaskOffset(offset);
break;
default:
AliWarning("No specific (SPD,SDD or SSD) subdetector correspond to to this number!!! all offsets set to zero for all the detectors\n");
SetTaskOffset(0, 0, 0);
break;
}
}
void AliITSQAChecker::SetDetHisto(Int_t subdet,Int_t histo)
{
switch(subdet){
case 1:
SetSPDHisto(histo);
break;
case 2:
SetSDDHisto(histo);
break;
case 3:
SetSSDHisto(histo);
break;
default:
AliWarning("No specific (SPD,SDD or SSD) subdetector correspond to to this number!!! all offsets set to zero for all the detectors\n");
SetHisto(0, 0, 0);
break;
}
}
void AliITSQAChecker::InitQACheckerLimits()
{
AliInfo("Setting of tolerance values\n");
Float_t lowtolerancevalue[AliQAv1::kNBIT];
Float_t hightolerancevalue[AliQAv1::kNBIT];
for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
{
lowtolerancevalue[bit]=(bit*1000.);
hightolerancevalue[bit]=((bit+1.)*1000.);
}
SetHiLo(hightolerancevalue,lowtolerancevalue);
if(fDet == 0 || fDet == 1) {
fSPDChecker->SetSPDLimits( lowtolerancevalue,hightolerancevalue );
}
if(fDet == 0 || fDet == 2) {
fSDDChecker->SetSDDLimits( lowtolerancevalue,hightolerancevalue );
}
if(fDet == 0 || fDet == 3) {
fSSDChecker->SetSSDLimits( lowtolerancevalue,hightolerancevalue );
}
}
void AliITSQAChecker::CreateStepForBit(Double_t histonumb,Double_t *steprange)
{
for(Int_t bit=0;bit < AliQAv1::kNBIT; bit++)
{
steprange[bit]=double((fUpTestValue[bit] - fLowTestValue[AliQAv1::kINFO])/histonumb);
}
}
void AliITSQAChecker::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
{
AliQAv1 * qa = AliQAv1::Instance(index) ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
if (! qa->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)))
continue ;
if ( value == NULL ) {
qa->Set(AliQAv1::kFATAL, specie) ;
} else {
if ( value[specie] > fLowTestValue[AliQAv1::kFATAL] && value[specie] <= fUpTestValue[AliQAv1::kFATAL] )
qa->Set(AliQAv1::kFATAL, AliRecoParam::ConvertIndex(specie)) ;
else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] && value[specie] <= fUpTestValue[AliQAv1::kERROR] )
qa->Set(AliQAv1::kERROR, AliRecoParam::ConvertIndex(specie)) ;
else if ( value[specie] > fLowTestValue[AliQAv1::kWARNING] && value[specie] <= fUpTestValue[AliQAv1::kWARNING] )
qa->Set(AliQAv1::kWARNING, AliRecoParam::ConvertIndex(specie)) ;
else if ( value[specie] > fLowTestValue[AliQAv1::kINFO] && value[specie] <= fUpTestValue[AliQAv1::kINFO] )
qa->Set(AliQAv1::kINFO, AliRecoParam::ConvertIndex(specie)) ;
}
qa->ShowStatus(AliQAv1::kITS,index,AliRecoParam::ConvertIndex(specie));
}
}
void AliITSQAChecker::MakeImage( TObjArray ** list, AliQAv1::TASKINDEX_t task, AliQAv1::MODE_t mode)
{
for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(esIndex)) )
continue ;
TIter next(list[esIndex]) ;
TH1 * hdata = NULL ;
while ( (hdata=static_cast<TH1 *>(next())) ) {
TString cln(hdata->ClassName()) ;
if ( ! cln.Contains("TH") )
continue ;
if(cln.Contains("TH2"))
{
Float_t min=hdata->GetMinimum();
Float_t max=hdata->GetMaximum();
if(max>min) hdata->SetOption("colz");
}
}
break ;
}
Bool_t retvalue=kFALSE;
if(GetSubDet()==0) MakeITSImage(list,task, mode);
else if(GetSubDet()==1)
{
retvalue=fSPDChecker->MakeSPDImage(list,task, mode) ;
if(retvalue==kFALSE)AliQACheckerBase::MakeImage(list,task, mode);
}
else if(GetSubDet()==2){ retvalue=fSDDChecker->MakeSDDImage(list,task, mode) ;if(retvalue==kFALSE)AliQACheckerBase::MakeImage(list,task,mode); }
else if(GetSubDet()==3)
{
retvalue=fSSDChecker->MakeSSDImage(list,task, mode) ;
if(retvalue==kFALSE)AliQACheckerBase::MakeImage(list,task, mode);
}
}