Add QA image (M. Siciliano, A. Mastroserio)
[u/mrichter/AliRoot.git] / 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