Add QA image (M. Siciliano, A. Mastroserio)
[u/mrichter/AliRoot.git] / ITS / AliITSQAChecker.cxx
CommitLineData
1507771f 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
3647765c 21// W.Ferrarese P.Cerello Mag 2008
1507771f 22// INFN Torino
23
24// --- ROOT system ---
5dfa9b71 25#include "TH1.h"
3647765c 26#include <Riostream.h>
8db5c9f9 27#include "TStyle.h"
1507771f 28
29// --- AliRoot header files ---
30#include "AliITSQAChecker.h"
5dfa9b71 31#include "AliITSQASPDChecker.h"
32#include "AliITSQASDDChecker.h"
33#include "AliITSQASSDChecker.h"
38cd6e1e 34#include "AliITSQADataMakerRec.h"
1507771f 35
36ClassImp(AliITSQAChecker)
37
5dfa9b71 38//____________________________________________________________________________
39AliITSQAChecker::AliITSQAChecker(Bool_t kMode, Short_t subDet, Short_t ldc) :
c71529b0 40AliQACheckerBase("ITS","SDD Quality Assurance Checker"),
41fkOnline(0),
42fDet(0),
43fLDC(0),
44fSPDOffset(0),
45fSDDOffset(0),
46fSSDOffset(0),
80b9610c 47fSPDHisto(0),
48fSDDHisto(0),
49fSSDHisto(0),
c71529b0 50fSPDChecker(0), // SPD Checker
51fSDDChecker(0), // SDD Checker
52fSSDChecker(0) // SSD Checker
80b9610c 53
5dfa9b71 54{
8b51d296 55 // Standard constructor
5dfa9b71 56 fkOnline = kMode; fDet = subDet; fLDC = ldc;
57 if(fDet == 0 || fDet == 1) {
5379c4a3 58 AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SPD Checker\n");
80b9610c 59 fSPDChecker = new AliITSQASPDChecker();
5dfa9b71 60 }
61 if(fDet == 0 || fDet == 2) {
5379c4a3 62 AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SDD Checker\n");
80b9610c 63 fSDDChecker = new AliITSQASDDChecker();
5dfa9b71 64 }
65 if(fDet == 0 || fDet == 3) {
5379c4a3 66 AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SSD Checker\n");
80b9610c 67 fSSDChecker = new AliITSQASSDChecker();
5dfa9b71 68 }
80b9610c 69 InitQACheckerLimits();
5dfa9b71 70}
71
5dfa9b71 72//____________________________________________________________________________
8b51d296 73AliITSQAChecker::AliITSQAChecker(const AliITSQAChecker& qac):
74AliQACheckerBase(qac.GetName(), qac.GetTitle()),
75fkOnline(qac.fkOnline),
76fDet(qac.fDet),
77fLDC(qac.fLDC),
78fSPDOffset(qac.fSPDOffset),
79fSDDOffset(qac.fSDDOffset),
80fSSDOffset(qac.fSSDOffset),
80b9610c 81fSPDHisto(qac.fSPDHisto),
82fSDDHisto(qac.fSDDHisto),
83fSSDHisto(qac.fSSDHisto),
84fSPDChecker(qac.fSPDChecker),
85fSDDChecker(qac.fSDDChecker),
86fSSDChecker(qac.fSSDChecker)
87{
8b51d296 88 // copy constructor
89 AliError("Copy should not be used with this class\n");
90}
91//____________________________________________________________________________
92AliITSQAChecker& AliITSQAChecker::operator=(const AliITSQAChecker& qac){
93 // assignment operator
94 this->~AliITSQAChecker();
95 new(this)AliITSQAChecker(qac);
96 return *this;
97}
98
fdd0de6a 99
100//____________________________________________________________________________
101AliITSQAChecker::~AliITSQAChecker(){
102 // destructor
103 if(fSPDChecker)delete fSPDChecker;
104 if(fSDDChecker)delete fSDDChecker;
105 if(fSSDChecker)delete fSSDChecker;
106
107}
8b51d296 108//____________________________________________________________________________
a42ceb0e 109void AliITSQAChecker::Check(Double_t * rv, AliQAv1::ALITASK_t index, TObjArray ** list, const AliDetectorRecoParam * recoParam)
5dfa9b71 110{
80b9610c 111
112
e62fe478 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
4e25ac79 115 if(index == AliQAv1::kESD){
a42ceb0e 116
57acd2d2 117 for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
118 rv[specie] = 0.0 ;
4e25ac79 119 if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
57acd2d2 120 continue ;
5379c4a3 121 AliDebug(AliQAv1::GetQADebugLevel(),"Checker for ESD");
57acd2d2 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
882ac7f1 133 }
57acd2d2 134 else {
80b9610c 135 Double_t *stepbit=new Double_t[AliQAv1::kNBIT];
136 Double_t histonumb= list[specie]->GetEntries();
137 CreateStepForBit(histonumb,stepbit);
57acd2d2 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;
5379c4a3 161 AliDebug(AliQAv1::GetQADebugLevel(),Form("ESD hist name %s - entries %12.1g",hname.Data(),entries));
57acd2d2 162 if(hname.Contains("hESDClusterMapSA") && entries>0.){
163 cluMapSA = kTRUE;
5379c4a3 164 AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
57acd2d2 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;
e62fe478 172 AliDebug(AliQAv1::GetQADebugLevel(),Form("SA tracks have few points on layer %d - look at histogram hESDClustersSA",k));
57acd2d2 173 }
174 }
175 }
8ea6e205 176
57acd2d2 177 else if(hname.Contains("hESDClusterMapMI") && entries>0.){
178 // Check if there are layers with anomalously low
179 // contributing points to MI reconstructed tracks
5379c4a3 180 AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
57acd2d2 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;
e62fe478 187 AliDebug(AliQAv1::GetQADebugLevel(),Form("MI tracks have few points on layer %d - look at histogram hESDClustersMI",k));
57acd2d2 188 }
189 }
190 }
8ea6e205 191
57acd2d2 192 else if(hname.Contains("hESDClustersMI") && entries>0.){
193 // Check if 6 clusters MI tracks are the majority
5379c4a3 194 AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
57acd2d2 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;
e62fe478 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));
57acd2d2 201 }
202 }
203 }
8ea6e205 204
57acd2d2 205 else if(hname.Contains("hESDClustersSA") && entries>0.){
206 // Check if 6 clusters SA tracks are the majority
5379c4a3 207 AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
57acd2d2 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;
5379c4a3 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));
57acd2d2 214 }
215 }
216 }
8ea6e205 217
57acd2d2 218 else if(hname.Contains("hSPDVertexZ") && entries>0.){
219 // Check if average Z vertex coordinate is -5 < z < 5 cm
5379c4a3 220 AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
57acd2d2 221 verSPDZ = kTRUE;
222 if(hdata->GetMean()<-5. && hdata->GetMean()>5.){
223 verSPDZ = kFALSE;
e62fe478 224 AliDebug(AliQAv1::GetQADebugLevel(),Form("Average z vertex coordinate is at z= %10.4g cm",hdata->GetMean()));
57acd2d2 225 }
226 }
227 }
57acd2d2 228 else{
229 AliError("ESD Checker - invalid data type");
230 }
e62fe478 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]));
57acd2d2 250 }
8ea6e205 251 } // end of ESD QA
e167dc41 252 else{
253
254 //____________________________________________________________________________
614c7e17 255
e167dc41 256 Double_t spdCheck[AliRecoParam::kNSpecies] ;
257 Double_t sddCheck[AliRecoParam::kNSpecies] ;
258 Double_t ssdCheck[AliRecoParam::kNSpecies] ;
80b9610c 259
260
261
57acd2d2 262 for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
e167dc41 263 if ( !AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
4e25ac79 264 if ( AliQAv1::Instance()->IsEventSpecieSet(specie) ) {
80b9610c 265 Double_t histotot=list[specie]->GetEntries();
266 if(histotot!=0)
267 {
268 spdCheck[specie]=0.;
269 sddCheck[specie]=0.;
270 ssdCheck[specie]=0.;
a42ceb0e 271 rv[specie] = 0.0 ;//
80b9610c 272 //pixel
273 if(fDet == 0 || fDet == 1) {
274 fSPDChecker->SetTaskOffset(fSPDOffset);
275 //printf("spdoffset = %i \n",fSPDOffset );
276 Double_t histoSPD=double(GetSPDHisto());
38cd6e1e 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];}
a42ceb0e 290 rv[specie]=spdCheck[specie];
38cd6e1e 291 }//end SPD check
80b9610c 292 //drift
293 if(fDet == 0 || fDet == 2) {
294 fSDDChecker->SetTaskOffset(fSDDOffset);
295 Double_t histoSDD=double(GetSDDHisto());
38cd6e1e 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
e167dc41 308 else{ssdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];}
a42ceb0e 309 if(sddCheck[specie]>rv[specie])rv[specie]=sddCheck[specie];
38cd6e1e 310 }//end SDD
80b9610c 311 //strip
312 if(fDet == 0 || fDet == 3) {
313 fSSDChecker->SetTaskOffset(fSSDOffset);
314 Double_t histoSSD=double(GetSSDHisto());
38cd6e1e 315 if(AliITSQADataMakerRec::AreEqual(histoSSD,0)==kFALSE){
80b9610c 316 Double_t *stepSSD=new Double_t[AliQAv1::kNBIT];
317 CreateStepForBit(histoSSD,stepSSD);
318 fSSDChecker->SetStepBit(stepSSD);
486788fc 319 ssdCheck[specie] = fSSDChecker->Check(index, list[specie], recoParam);
80b9610c 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 }
80b9610c 325 delete [] stepSSD;
38cd6e1e 326 }//end check SSD entries
e167dc41 327 else{ssdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];}
a42ceb0e 328 if(ssdCheck[specie]>rv[specie])rv[specie]=ssdCheck[specie];
38cd6e1e 329 }//end SSD
80b9610c 330
a42ceb0e 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]));
80b9610c 332 // here merging part for common ITS QA result
333 //
334 }//end entries
335 }//end if event specie
336 }//end for
e167dc41 337 }
5dfa9b71 338}
339
c71529b0 340//____________________________________________________________________________
341void 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}
614c7e17 348
80b9610c 349//____________________________________________________________________________
350void 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
614c7e17 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 }
80b9610c 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
400void 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
433void 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//_____________________________________________________________________________
446void 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
8db5c9f9 475//__________________________________________________________________
476void 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