ITS/AliITSQAChecker.cxx

   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 //  W.Ferrarese  P.Cerello  Mag 2008
  22 //  INFN Torino
  23
  24 // --- ROOT system ---
  25 #include "TH1.h"
  26 #include <Riostream.h>
  27 #include "TStyle.h"
  28
  29 // --- AliRoot header files ---
  30 #include "AliITSQAChecker.h"
  31 #include "AliITSQASPDChecker.h"
  32 #include "AliITSQASDDChecker.h"
  33 #include "AliITSQASSDChecker.h"
  34 #include "AliITSQADataMakerRec.h"
  35
  36 ClassImp(AliITSQAChecker)
  37
  38 //____________________________________________________________________________
  39 AliITSQAChecker::AliITSQAChecker(Bool_t kMode, Short_t subDet, Short_t ldc) :
  40 AliQACheckerBase("ITS","SDD Quality Assurance Checker"),
  41 fkOnline(0),
  42 fDet(0),
  43 fLDC(0),
  44 fSPDOffset(0),
  45 fSDDOffset(0),
  46 fSSDOffset(0),
  47 fSPDHisto(0),
  48 fSDDHisto(0),
  49 fSSDHisto(0),
  50 fSPDChecker(0),  // SPD Checker
  51 fSDDChecker(0),  // SDD Checker
  52 fSSDChecker(0)  // SSD Checker
  53
  54 {
  55   // Standard constructor
  56   fkOnline = kMode; fDet = subDet; fLDC = ldc;
  57   if(fDet == 0 || fDet == 1) {
  58     AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SPD Checker\n");
  59     fSPDChecker = new AliITSQASPDChecker();
  60   }
  61   if(fDet == 0 || fDet == 2) {
  62     AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SDD Checker\n");
  63     fSDDChecker = new AliITSQASDDChecker();
  64   }
  65   if(fDet == 0 || fDet == 3) {
  66     AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SSD Checker\n");
  67     fSSDChecker = new AliITSQASSDChecker();
  68   }
  69   InitQACheckerLimits();
  70 }
  71
  72 //____________________________________________________________________________
  73 AliITSQAChecker::~AliITSQAChecker(){
  74   // destructor
  75   if(fSPDChecker)delete fSPDChecker;
  76   if(fSDDChecker)delete fSDDChecker;
  77   if(fSSDChecker)delete fSSDChecker;
  78
  79 }
  80 //____________________________________________________________________________
  81 void AliITSQAChecker::Check(Double_t * rv, AliQAv1::ALITASK_t index, TObjArray ** list, const AliDetectorRecoParam * recoParam)
  82 {
  83
  84
  85   // basic checks on the QA histograms on the input list
  86   //for the ITS subdetectorQA (Raws Digits Hits RecPoints SDigits) return the worst value of the three result
  87   if(index == AliQAv1::kESD){
  88
  89     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
  90       rv[specie] = 0.0 ;
  91       if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
  92         continue ;
  93       AliDebug(AliQAv1::GetQADebugLevel(),"Checker for ESD");
  94       Int_t tested = 0;
  95       Int_t empty = 0;
  96       // The following flags are set to kTRUE if the corresponding
  97       // QA histograms exceed a given quality threshold
  98       Bool_t cluMapSA = kFALSE;
  99       Bool_t cluMapMI = kFALSE;
 100       Bool_t cluMI = kFALSE;
 101       Bool_t cluSA = kFALSE;
 102       Bool_t verSPDZ = kFALSE;
 103       if (list[specie]->GetEntries() == 0) {
 104         rv[specie] = 0.; // nothing to check
 105       }
 106       else {
 107         Double_t stepbit[AliQAv1::kNBIT];
 108         Double_t histonumb= list[specie]->GetEntries();
 109         CreateStepForBit(histonumb,stepbit);
 110         TIter next1(list[specie]);
 111         TH1 * hdata;
 112         Int_t nskipped=0;
 113         Bool_t skipped[6]={kFALSE,kFALSE,kFALSE,kFALSE,kFALSE,kFALSE};
 114         // look for layers that we wanted to skip
 115         while ( (hdata = dynamic_cast<TH1 *>(next1())) ) {
 116           if(hdata){
 117             TString hname = hdata->GetName();
 118             if(!hname.Contains("hESDSkippedLayers")) continue;
 119             for(Int_t k=1; k<7; k++) {
 120               if(hdata->GetBinContent(k)>0) {
 121                 nskipped++;
 122                 skipped[k-1]=kTRUE;
 123               }
 124             }
 125           }
 126         }
 127         TIter next(list[specie]);
 128         while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
 129           if(hdata){
 130             TString hname = hdata->GetName();
 131             Double_t entries = hdata->GetEntries();
 132             ++tested;
 133             if(!(entries>0.))++empty;
 134             AliDebug(AliQAv1::GetQADebugLevel(),Form("ESD hist name %s - entries %12.1g",hname.Data(),entries));
 135             if(hname.Contains("hESDClusterMapSA") && entries>0.){
 136               cluMapSA = kTRUE;
 137               AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
 138               // Check if there are layers with anomalously low
 139               // contributing points to SA reconstructed tracks
 140               for(Int_t k=1;k<7;k++){
 141                 // check if the layer was skipped
 142                 if(skipped[k-1]) continue;
 143                 if(hdata->GetBinContent(k)<0.5*(entries/6.)){
 144                   cluMapSA = kFALSE;
 145                   AliDebug(AliQAv1::GetQADebugLevel(),Form("SA tracks have few points on layer %d - look at histogram hESDClustersSA",k));
 146                 }
 147               }
 148             }//end clustermapsa
 149
 150             else if(hname.Contains("hESDClusterMapMI") && entries>0.){
 151               // Check if there are layers with anomalously low
 152               // contributing points to MI reconstructed tracks
 153               AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
 154               cluMapMI = kTRUE;
 155               for(Int_t k=1;k<7;k++){
 156                 // check if the layer was skipped
 157                 if(skipped[k-1]) continue;
 158                 if(hdata->GetBinContent(k)<0.5*(entries/6.)){
 159                   cluMapMI = kFALSE;
 160                   AliDebug(AliQAv1::GetQADebugLevel(),Form("MI tracks have few points on layer %d - look at histogram hESDClustersMI",k));
 161                 }
 162               }
 163             }//end clustermapmi
 164
 165             else if(hname.Contains("hESDClustersMI") && entries>0.){
 166               // Check if 6 clusters MI tracks are the majority
 167               AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
 168               cluMI = kTRUE;
 169               Double_t maxlaytracks = hdata->GetBinContent(7-nskipped);
 170               for(Int_t k=2; k<7-nskipped; k++){
 171                 if(hdata->GetBinContent(k)>maxlaytracks){
 172                   cluMI = kFALSE;
 173                   AliDebug(AliQAv1::GetQADebugLevel(),Form("MI Tracks with %d clusters are more than tracks with %d clusters. Look at histogram hESDClustersMI",k-1,6-nskipped));
 174                 }
 175               }
 176             }//end clustersmi
 177
 178             else if(hname.Contains("hESDClustersSA") && entries>0.){
 179               // Check if 6 clusters SA tracks are the majority
 180               AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
 181               cluSA = kTRUE;
 182               Double_t maxlaytracks = hdata->GetBinContent(7-nskipped);
 183               for(Int_t k=2; k<7-nskipped; k++){
 184                 if(hdata->GetBinContent(k)>maxlaytracks){
 185                   cluSA = kFALSE;
 186                   AliDebug(AliQAv1::GetQADebugLevel(), Form("SA Tracks with %d clusters are more than tracks with %d clusters. Look at histogram hESDClustersSA",k-1,6-nskipped));
 187                 }
 188               }
 189             }//end clusterssa
 190
 191             else if(hname.Contains("hSPDVertexZ") && entries>0.){
 192               // Check if average Z vertex coordinate is -5 < z < 5 cm
 193               AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
 194               verSPDZ = kTRUE;
 195               if(hdata->GetMean()<-5. && hdata->GetMean()>5.){
 196                 verSPDZ = kFALSE;
 197                 AliDebug(AliQAv1::GetQADebugLevel(),Form("Average z vertex coordinate is at z= %10.4g cm",hdata->GetMean()));
 198               }
 199             }//end spdvertexz
 200
 201             else{ AliError("ESD Checker - invalid data type");}//end else
 202
 203             rv[specie] = 0.;
 204             if(tested>0){
 205               if(tested == empty){
 206                 rv[specie] = 2500.; // set to error
 207                 AliWarning(Form("All ESD histograms are empty - specie=%d",specie));
 208               }
 209               else {
 210                 rv[specie] = 2500.-1500.*(static_cast<Double_t>(tested-empty)/static_cast<Double_t>(tested)); // INFO if all histos are filled
 211                 if(cluMapSA)rv[specie]-=200.;
 212                 if(cluMapMI)rv[specie]-=200.;
 213                 if(cluMI)rv[specie]-=200.;
 214                 if(cluSA)rv[specie]-=200.;
 215                 if(verSPDZ)rv[specie]-=199.;  // down to 1 if everything is OK
 216               }
 217             }//end tested
 218           }//end hdata
 219         }//end while
 220         //     AliDebug(AliQAv1::GetQADebugLevel(), Form("ESD - Tested %d histograms, Return value %f \n",tested,rv[specie]));
 221         AliInfo(Form("ESD - Tested %d histograms, Return value %f \n",tested,rv[specie]));
 222       }
 223     }
 224   } // end of ESD QA
 225   else{
 226
 227     //____________________________________________________________________________
 228
 229     Double_t spdCheck[AliRecoParam::kNSpecies] ;
 230     Double_t sddCheck[AliRecoParam::kNSpecies] ;
 231     Double_t ssdCheck[AliRecoParam::kNSpecies] ;
 232
 233
 234
 235     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
 236       if ( !AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
 237       if ( AliQAv1::Instance()->IsEventSpecieSet(specie) ) {
 238         Double_t histotot=list[specie]->GetEntries();
 239         if(histotot!=0)
 240           {
 241             spdCheck[specie]=0.;
 242             sddCheck[specie]=0.;
 243             ssdCheck[specie]=0.;
 244             rv[specie] = 0.0 ;//
 245             //pixel
 246             if(fDet == 0 || fDet == 1) {
 247               fSPDChecker->SetTaskOffset(fSPDOffset);
 248               //printf("spdoffset = %i \n",fSPDOffset );
 249               Double_t histoSPD=double(GetSPDHisto());
 250               if(AliITSQADataMakerRec::AreEqual(histoSPD,0)==kFALSE){
 251                 Double_t *stepSPD=new Double_t[AliQAv1::kNBIT];
 252                 CreateStepForBit(histoSPD,stepSPD);
 253                 fSPDChecker->SetStepBit(stepSPD);
 254                 spdCheck[specie] = fSPDChecker->Check(index, list[specie], recoParam);
 255                 if(spdCheck[specie]>fUpTestValue[AliQAv1::kFATAL]||spdCheck[specie]<0.)
 256                   {
 257                     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)));
 258                     spdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];
 259                   }
 260                 delete []stepSPD;
 261               }//end check SPD entries
 262               else{spdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];}
 263               rv[specie]=spdCheck[specie];
 264             }//end SPD check
 265             //drift
 266             if(fDet == 0 || fDet == 2) {
 267               fSDDChecker->SetTaskOffset(fSDDOffset);
 268               fSDDChecker->SetEventSpecieForCheck(specie);
 269               Double_t histoSDD=double(GetSDDHisto());
 270               if(AliITSQADataMakerRec::AreEqual(histoSDD,0)==kFALSE){
 271                 Double_t *stepSDD=new Double_t[AliQAv1::kNBIT];
 272                 CreateStepForBit(histoSDD,stepSDD);
 273                 fSDDChecker->SetStepBit(stepSDD);
 274                 sddCheck[specie] = fSDDChecker->Check(index, list[specie], recoParam);
 275                 if(sddCheck[specie]>fUpTestValue[AliQAv1::kFATAL]||sddCheck[specie]<0.)
 276                   {
 277                     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)));
 278                     sddCheck[specie]=fUpTestValue[AliQAv1::kFATAL];
 279                   }
 280                 delete []stepSDD;
 281               }//end check SDD entries
 282               else{ssdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];}
 283               if(sddCheck[specie]>rv[specie])rv[specie]=sddCheck[specie];
 284             }//end SDD
 285             //strip
 286             if(fDet == 0 || fDet == 3) {
 287               fSSDChecker->SetTaskOffset(fSSDOffset);
 288               Double_t histoSSD=double(GetSSDHisto());
 289               if(AliITSQADataMakerRec::AreEqual(histoSSD,0)==kFALSE){
 290               Double_t *stepSSD=new Double_t[AliQAv1::kNBIT];
 291               CreateStepForBit(histoSSD,stepSSD);
 292               fSSDChecker->SetStepBit(stepSSD);
 293               ssdCheck[specie] = fSSDChecker->Check(index, list[specie], recoParam);
 294               if(ssdCheck[specie]>fUpTestValue[AliQAv1::kFATAL]||ssdCheck[specie]<0.)
 295                 {
 296                   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)));
 297                   ssdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];
 298                 }
 299               delete [] stepSSD;
 300               }//end check SSD entries
 301               else{ssdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];}
 302               if(ssdCheck[specie]>rv[specie])rv[specie]=ssdCheck[specie];
 303             }//end SSD
 304
 305             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]));
 306             // here merging part for common ITS QA result
 307             //
 308           }//end entries
 309       }//end if event specie
 310     }//end for
 311   }
 312 }
 313
 314 //____________________________________________________________________________
 315 void AliITSQAChecker::SetTaskOffset(Int_t SPDOffset, Int_t SDDOffset, Int_t SSDOffset)
 316 {
 317   //Setting the 3 offsets for each task called
 318   fSPDOffset = SPDOffset;
 319   fSDDOffset = SDDOffset;
 320   fSSDOffset = SSDOffset;
 321 }
 322
 323 //____________________________________________________________________________
 324 void AliITSQAChecker::SetHisto(Int_t SPDhisto, Int_t SDDhisto, Int_t SSDhisto)
 325 {
 326   //Setting the 3 offsets for each task called
 327   fSPDHisto = SPDhisto;
 328   fSDDHisto = SDDhisto;
 329   fSSDHisto = SSDhisto;
 330 }
 331
 332  //____________________________________________________________________________
 333  void AliITSQAChecker::SetDetTaskOffset(Int_t subdet,Int_t offset)
 334  {
 335    //returns the offset for each task and for each subdetector
 336    switch(subdet){
 337    case 1:
 338      SetSPDTaskOffset(offset);
 339      break;
 340    case 2:
 341      SetSDDTaskOffset(offset);
 342      break;
 343    case 3:
 344      SetSSDTaskOffset(offset);
 345      break;
 346    default:
 347      AliWarning("No specific (SPD,SDD or SSD) subdetector correspond to to this number!!! all offsets set to zero for all the detectors\n");
 348      SetTaskOffset(0, 0, 0);
 349      break;
 350    }
 351  }
 352
 353  //____________________________________________________________________________
 354  void AliITSQAChecker::SetDetHisto(Int_t subdet,Int_t histo)
 355  {
 356    //set the number od histograms for the subdetector
 357    switch(subdet){
 358    case 1:
 359      SetSPDHisto(histo);
 360      break;
 361    case 2:
 362      SetSDDHisto(histo);
 363      break;
 364    case 3:
 365      SetSSDHisto(histo);
 366      break;
 367    default:
 368      AliWarning("No specific (SPD,SDD or SSD) subdetector correspond to to this number!!! all offsets set to zero for all the detectors\n");
 369      SetHisto(0, 0, 0);
 370      break;
 371    }
 372  }
 373
 374 //_____________________________________________________________________________
 375
 376 void AliITSQAChecker::InitQACheckerLimits()
 377 {
 378   //init the tolerance range for each QA bit
 379   AliInfo("Setting of tolerance values\n");
 380
 381   Float_t lowtolerancevalue[AliQAv1::kNBIT];
 382
 383   Float_t hightolerancevalue[AliQAv1::kNBIT];
 384   for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
 385     {
 386       lowtolerancevalue[bit]=(bit*1000.);
 387       hightolerancevalue[bit]=((bit+1.)*1000.);
 388     }
 389   SetHiLo(hightolerancevalue,lowtolerancevalue);
 390   //  AliInfo(Form("Range Value  \n INFO    -> %f <  value <  %f \n WARNING -> %f <  value <= %f \n ERROR   -> %f <  value <= %f \n FATAL   -> %f <= value <  %f \n", fLowTestValue[AliQAv1::kINFO], fUpTestValue[AliQAv1::kINFO], fLowTestValue[AliQAv1::kWARNING], fUpTestValue[AliQAv1::kWARNING], fLowTestValue[AliQAv1::kERROR], fUpTestValue[AliQAv1::kERROR], fLowTestValue[AliQAv1::kFATAL], fUpTestValue[AliQAv1::kFATAL]  ));
 391
 392   if(fDet == 0 || fDet == 1) {
 393     fSPDChecker->SetSPDLimits( lowtolerancevalue,hightolerancevalue );
 394   }
 395   if(fDet == 0 || fDet == 2) {
 396     fSDDChecker->SetSDDLimits( lowtolerancevalue,hightolerancevalue );
 397   }
 398   if(fDet == 0 || fDet == 3) {
 399     fSSDChecker->SetSSDLimits( lowtolerancevalue,hightolerancevalue );
 400   }
 401
 402
 403
 404 }
 405
 406
 407 //_____________________________________________________________________________
 408
 409 void AliITSQAChecker::CreateStepForBit(Double_t histonumb,Double_t *steprange)
 410 {
 411   //creation of the step bit for each QA bit
 412   for(Int_t bit=0;bit < AliQAv1::kNBIT; bit++)
 413     {
 414       //printf("%i\t %f \t %f \t %f \n",bit, fUpTestValue[bit],fLowTestValue[AliQAv1::kINFO],histonumb);
 415       steprange[bit]=double((fUpTestValue[bit] - fLowTestValue[AliQAv1::kINFO])/histonumb);
 416       //printf("%i\t %f \t %f \t %f \t %f\n",bit, fUpTestValue[bit],fLowTestValue[AliQAv1::kINFO],histonumb,steprange[bit] );
 417     }
 418   //AliInfo(Form("StepBitValue:numner of histo %f\n\t INFO %f \t WARNING %f \t ERROR %f \t FATAL %f \n",histonumb, steprange[AliQAv1::kINFO],steprange[AliQAv1::kWARNING],steprange[AliQAv1::kERROR],steprange[AliQAv1::kFATAL]));
 419 }
 420
 421
 422 //_____________________________________________________________________________
 423 void AliITSQAChecker::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
 424 {
 425   //Setting of the QA tolerance values
 426   AliQAv1 * qa = AliQAv1::Instance(index) ;
 427
 428
 429   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
 430
 431     if (! qa->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)))
 432       continue ;
 433     if (  value == NULL ) { // No checker is implemented, set all QA to Fatal
 434       qa->Set(AliQAv1::kFATAL, specie) ;
 435     } else {
 436       if ( value[specie] > fLowTestValue[AliQAv1::kFATAL] && value[specie] <= fUpTestValue[AliQAv1::kFATAL] )
 437         qa->Set(AliQAv1::kFATAL, AliRecoParam::ConvertIndex(specie)) ;
 438       else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] && value[specie] <= fUpTestValue[AliQAv1::kERROR]  )
 439         qa->Set(AliQAv1::kERROR, AliRecoParam::ConvertIndex(specie)) ;
 440       else if ( value[specie] > fLowTestValue[AliQAv1::kWARNING] && value[specie] <= fUpTestValue[AliQAv1::kWARNING]  )
 441         qa->Set(AliQAv1::kWARNING, AliRecoParam::ConvertIndex(specie)) ;
 442       else if ( value[specie] > fLowTestValue[AliQAv1::kINFO] && value[specie] <= fUpTestValue[AliQAv1::kINFO] )
 443         qa->Set(AliQAv1::kINFO, AliRecoParam::ConvertIndex(specie)) ;
 444       //else if(value[specie]==0) qa->Set(AliQAv1::kFATAL, AliRecoParam::ConvertIndex(specie)) ; //no ckeck has been done
 445     }
 446     qa->ShowStatus(AliQAv1::kITS,index,AliRecoParam::ConvertIndex(specie));
 447   }//end for
 448
 449 }
 450
 451
 452 //__________________________________________________________________
 453 void  AliITSQAChecker::MakeImage( TObjArray ** list, AliQAv1::TASKINDEX_t task, AliQAv1::MODE_t mode)
 454 {
 455   //make a summary image
 456   //gStyle->SetPalette(1);
 457
 458   //Int_t nImages = 0 ;
 459   //Int_t imageindex=0;
 460   for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
 461     if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(esIndex)) )
 462       continue ;
 463     //else imageindex=esIndex;
 464
 465     TIter next(list[esIndex]) ;
 466     TH1 * hdata = NULL ;
 467     while ( (hdata=static_cast<TH1 *>(next())) ) {
 468       TString cln(hdata->ClassName()) ;
 469       if ( ! cln.Contains("TH") )
 470         continue ;
 471       if(cln.Contains("TH2"))
 472         {
 473           Float_t min=hdata->GetMinimum();
 474           Float_t max=hdata->GetMaximum();
 475           if(max>min) hdata->SetOption("colz");
 476         }
 477     }
 478     break ;
 479   }
 480
 481   Bool_t retvalue=kFALSE;
 482
 483   if(GetSubDet()==0) MakeITSImage(list,task, mode);
 484   else if(GetSubDet()==1)
 485     {
 486       retvalue=fSPDChecker->MakeSPDImage(list,task, mode) ;
 487       if(retvalue==kFALSE)AliQACheckerBase::MakeImage(list,task, mode);
 488     }
 489   else if(GetSubDet()==2){ retvalue=fSDDChecker->MakeSDDImage(list,task, mode) ;if(retvalue==kFALSE)AliQACheckerBase::MakeImage(list,task,mode); }
 490   else if(GetSubDet()==3)
 491     {
 492       retvalue=fSSDChecker->MakeSSDImage(list,task, mode) ;
 493       if(retvalue==kFALSE)AliQACheckerBase::MakeImage(list,task, mode);
 494     }
 495
 496 }
 497