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