]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ITS/AliITSQAChecker.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Be sure to load mapping when needed
[u/mrichter/AliRoot.git] / ITS / AliITSQAChecker.cxx
CommitLineData
a6a921e0 1 /**************************************************************************
1507771f 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
8b51d296 72//____________________________________________________________________________
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}
57acd2d2 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 {
d2f99642 135 Double_t stepbit[AliQAv1::kNBIT];
80b9610c 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())) ) {
d2f99642 144 if(hdata){
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 }
57acd2d2 155 TIter next(list[specie]);
156 while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
157 if(hdata){
158 TString hname = hdata->GetName();
159 Double_t entries = hdata->GetEntries();
160 ++tested;
161 if(!(entries>0.))++empty;
5379c4a3 162 AliDebug(AliQAv1::GetQADebugLevel(),Form("ESD hist name %s - entries %12.1g",hname.Data(),entries));
57acd2d2 163 if(hname.Contains("hESDClusterMapSA") && entries>0.){
164 cluMapSA = kTRUE;
5379c4a3 165 AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
57acd2d2 166 // Check if there are layers with anomalously low
167 // contributing points to SA reconstructed tracks
168 for(Int_t k=1;k<7;k++){
169 // check if the layer was skipped
170 if(skipped[k-1]) continue;
171 if(hdata->GetBinContent(k)<0.5*(entries/6.)){
172 cluMapSA = kFALSE;
e62fe478 173 AliDebug(AliQAv1::GetQADebugLevel(),Form("SA tracks have few points on layer %d - look at histogram hESDClustersSA",k));
57acd2d2 174 }
175 }
d2f99642 176 }//end clustermapsa
177
57acd2d2 178 else if(hname.Contains("hESDClusterMapMI") && entries>0.){
179 // Check if there are layers with anomalously low
180 // contributing points to MI reconstructed tracks
5379c4a3 181 AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
57acd2d2 182 cluMapMI = kTRUE;
183 for(Int_t k=1;k<7;k++){
184 // check if the layer was skipped
185 if(skipped[k-1]) continue;
186 if(hdata->GetBinContent(k)<0.5*(entries/6.)){
187 cluMapMI = kFALSE;
e62fe478 188 AliDebug(AliQAv1::GetQADebugLevel(),Form("MI tracks have few points on layer %d - look at histogram hESDClustersMI",k));
57acd2d2 189 }
190 }
d2f99642 191 }//end clustermapmi
192
57acd2d2 193 else if(hname.Contains("hESDClustersMI") && entries>0.){
194 // Check if 6 clusters MI tracks are the majority
5379c4a3 195 AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
57acd2d2 196 cluMI = kTRUE;
197 Double_t maxlaytracks = hdata->GetBinContent(7-nskipped);
198 for(Int_t k=2; k<7-nskipped; k++){
199 if(hdata->GetBinContent(k)>maxlaytracks){
200 cluMI = kFALSE;
e62fe478 201 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 202 }
203 }
d2f99642 204 }//end clustersmi
205
57acd2d2 206 else if(hname.Contains("hESDClustersSA") && entries>0.){
207 // Check if 6 clusters SA tracks are the majority
5379c4a3 208 AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
57acd2d2 209 cluSA = kTRUE;
210 Double_t maxlaytracks = hdata->GetBinContent(7-nskipped);
211 for(Int_t k=2; k<7-nskipped; k++){
212 if(hdata->GetBinContent(k)>maxlaytracks){
213 cluSA = kFALSE;
5379c4a3 214 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 215 }
216 }
d2f99642 217 }//end clusterssa
218
57acd2d2 219 else if(hname.Contains("hSPDVertexZ") && entries>0.){
220 // Check if average Z vertex coordinate is -5 < z < 5 cm
5379c4a3 221 AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
57acd2d2 222 verSPDZ = kTRUE;
223 if(hdata->GetMean()<-5. && hdata->GetMean()>5.){
224 verSPDZ = kFALSE;
e62fe478 225 AliDebug(AliQAv1::GetQADebugLevel(),Form("Average z vertex coordinate is at z= %10.4g cm",hdata->GetMean()));
57acd2d2 226 }
d2f99642 227 }//end spdvertexz
228
229 else{ AliError("ESD Checker - invalid data type");}//end else
230
231 rv[specie] = 0.;
232 if(tested>0){
233 if(tested == empty){
234 rv[specie] = 2500.; // set to error
235 AliWarning(Form("All ESD histograms are empty - specie=%d",specie));
236 }
237 else {
238 rv[specie] = 2500.-1500.*(static_cast<Double_t>(tested-empty)/static_cast<Double_t>(tested)); // INFO if all histos are filled
239 if(cluMapSA)rv[specie]-=200.;
240 if(cluMapMI)rv[specie]-=200.;
241 if(cluMI)rv[specie]-=200.;
242 if(cluSA)rv[specie]-=200.;
243 if(verSPDZ)rv[specie]-=199.; // down to 1 if everything is OK
244 }
245 }//end tested
246 }//end hdata
247 }//end while
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]));
e62fe478 250 }
57acd2d2 251 }
d2f99642 252 } // end of ESD QA
e167dc41 253 else{
254
255 //____________________________________________________________________________
614c7e17 256
e167dc41 257 Double_t spdCheck[AliRecoParam::kNSpecies] ;
258 Double_t sddCheck[AliRecoParam::kNSpecies] ;
259 Double_t ssdCheck[AliRecoParam::kNSpecies] ;
80b9610c 260
261
262
57acd2d2 263 for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
e167dc41 264 if ( !AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
4e25ac79 265 if ( AliQAv1::Instance()->IsEventSpecieSet(specie) ) {
80b9610c 266 Double_t histotot=list[specie]->GetEntries();
267 if(histotot!=0)
268 {
269 spdCheck[specie]=0.;
270 sddCheck[specie]=0.;
271 ssdCheck[specie]=0.;
a42ceb0e 272 rv[specie] = 0.0 ;//
80b9610c 273 //pixel
274 if(fDet == 0 || fDet == 1) {
275 fSPDChecker->SetTaskOffset(fSPDOffset);
276 //printf("spdoffset = %i \n",fSPDOffset );
277 Double_t histoSPD=double(GetSPDHisto());
38cd6e1e 278 if(AliITSQADataMakerRec::AreEqual(histoSPD,0)==kFALSE){
279 Double_t *stepSPD=new Double_t[AliQAv1::kNBIT];
280 CreateStepForBit(histoSPD,stepSPD);
281 fSPDChecker->SetStepBit(stepSPD);
282 spdCheck[specie] = fSPDChecker->Check(index, list[specie], recoParam);
283 if(spdCheck[specie]>fUpTestValue[AliQAv1::kFATAL]||spdCheck[specie]<0.)
284 {
285 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)));
286 spdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];
287 }
288 delete []stepSPD;
289 }//end check SPD entries
290 else{spdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];}
a42ceb0e 291 rv[specie]=spdCheck[specie];
38cd6e1e 292 }//end SPD check
80b9610c 293 //drift
294 if(fDet == 0 || fDet == 2) {
295 fSDDChecker->SetTaskOffset(fSDDOffset);
25b4170b 296 fSDDChecker->SetEventSpecieForCheck(specie);
80b9610c 297 Double_t histoSDD=double(GetSDDHisto());
38cd6e1e 298 if(AliITSQADataMakerRec::AreEqual(histoSDD,0)==kFALSE){
299 Double_t *stepSDD=new Double_t[AliQAv1::kNBIT];
300 CreateStepForBit(histoSDD,stepSDD);
301 fSDDChecker->SetStepBit(stepSDD);
302 sddCheck[specie] = fSDDChecker->Check(index, list[specie], recoParam);
303 if(sddCheck[specie]>fUpTestValue[AliQAv1::kFATAL]||sddCheck[specie]<0.)
304 {
305 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)));
306 sddCheck[specie]=fUpTestValue[AliQAv1::kFATAL];
307 }
308 delete []stepSDD;
309 }//end check SDD entries
e167dc41 310 else{ssdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];}
a42ceb0e 311 if(sddCheck[specie]>rv[specie])rv[specie]=sddCheck[specie];
38cd6e1e 312 }//end SDD
80b9610c 313 //strip
314 if(fDet == 0 || fDet == 3) {
315 fSSDChecker->SetTaskOffset(fSSDOffset);
316 Double_t histoSSD=double(GetSSDHisto());
38cd6e1e 317 if(AliITSQADataMakerRec::AreEqual(histoSSD,0)==kFALSE){
80b9610c 318 Double_t *stepSSD=new Double_t[AliQAv1::kNBIT];
319 CreateStepForBit(histoSSD,stepSSD);
320 fSSDChecker->SetStepBit(stepSSD);
486788fc 321 ssdCheck[specie] = fSSDChecker->Check(index, list[specie], recoParam);
80b9610c 322 if(ssdCheck[specie]>fUpTestValue[AliQAv1::kFATAL]||ssdCheck[specie]<0.)
323 {
324 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)));
325 ssdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];
326 }
80b9610c 327 delete [] stepSSD;
38cd6e1e 328 }//end check SSD entries
e167dc41 329 else{ssdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];}
a42ceb0e 330 if(ssdCheck[specie]>rv[specie])rv[specie]=ssdCheck[specie];
38cd6e1e 331 }//end SSD
80b9610c 332
a42ceb0e 333 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 334 // here merging part for common ITS QA result
335 //
336 }//end entries
337 }//end if event specie
338 }//end for
e167dc41 339 }
5dfa9b71 340}
341
c71529b0 342//____________________________________________________________________________
343void AliITSQAChecker::SetTaskOffset(Int_t SPDOffset, Int_t SDDOffset, Int_t SSDOffset)
344{
345 //Setting the 3 offsets for each task called
346 fSPDOffset = SPDOffset;
347 fSDDOffset = SDDOffset;
348 fSSDOffset = SSDOffset;
349}
614c7e17 350
80b9610c 351//____________________________________________________________________________
352void AliITSQAChecker::SetHisto(Int_t SPDhisto, Int_t SDDhisto, Int_t SSDhisto)
353{
354 //Setting the 3 offsets for each task called
355 fSPDHisto = SPDhisto;
356 fSDDHisto = SDDhisto;
357 fSSDHisto = SSDhisto;
358}
359
614c7e17 360 //____________________________________________________________________________
361 void AliITSQAChecker::SetDetTaskOffset(Int_t subdet,Int_t offset)
362 {
9b94f977 363 //returns the offset for each task and for each subdetector
614c7e17 364 switch(subdet){
365 case 1:
366 SetSPDTaskOffset(offset);
367 break;
368 case 2:
369 SetSDDTaskOffset(offset);
370 break;
371 case 3:
372 SetSSDTaskOffset(offset);
373 break;
374 default:
375 AliWarning("No specific (SPD,SDD or SSD) subdetector correspond to to this number!!! all offsets set to zero for all the detectors\n");
376 SetTaskOffset(0, 0, 0);
377 break;
378 }
379 }
80b9610c 380
381 //____________________________________________________________________________
382 void AliITSQAChecker::SetDetHisto(Int_t subdet,Int_t histo)
383 {
9b94f977 384 //set the number od histograms for the subdetector
80b9610c 385 switch(subdet){
386 case 1:
387 SetSPDHisto(histo);
388 break;
389 case 2:
390 SetSDDHisto(histo);
391 break;
392 case 3:
393 SetSSDHisto(histo);
394 break;
395 default:
396 AliWarning("No specific (SPD,SDD or SSD) subdetector correspond to to this number!!! all offsets set to zero for all the detectors\n");
397 SetHisto(0, 0, 0);
398 break;
399 }
400 }
401
402//_____________________________________________________________________________
403
404void AliITSQAChecker::InitQACheckerLimits()
405{
9b94f977 406 //init the tolerance range for each QA bit
80b9610c 407 AliInfo("Setting of tolerance values\n");
408
409 Float_t lowtolerancevalue[AliQAv1::kNBIT];
410
411 Float_t hightolerancevalue[AliQAv1::kNBIT];
412 for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
413 {
414 lowtolerancevalue[bit]=(bit*1000.);
415 hightolerancevalue[bit]=((bit+1.)*1000.);
416 }
417 SetHiLo(hightolerancevalue,lowtolerancevalue);
418 // 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] ));
419
420 if(fDet == 0 || fDet == 1) {
421 fSPDChecker->SetSPDLimits( lowtolerancevalue,hightolerancevalue );
422 }
423 if(fDet == 0 || fDet == 2) {
424 fSDDChecker->SetSDDLimits( lowtolerancevalue,hightolerancevalue );
425 }
426 if(fDet == 0 || fDet == 3) {
427 fSSDChecker->SetSSDLimits( lowtolerancevalue,hightolerancevalue );
428 }
429
430
431
432}
433
434
435//_____________________________________________________________________________
436
437void AliITSQAChecker::CreateStepForBit(Double_t histonumb,Double_t *steprange)
438{
9b94f977 439 //creation of the step bit for each QA bit
80b9610c 440 for(Int_t bit=0;bit < AliQAv1::kNBIT; bit++)
441 {
442 //printf("%i\t %f \t %f \t %f \n",bit, fUpTestValue[bit],fLowTestValue[AliQAv1::kINFO],histonumb);
443 steprange[bit]=double((fUpTestValue[bit] - fLowTestValue[AliQAv1::kINFO])/histonumb);
444 //printf("%i\t %f \t %f \t %f \t %f\n",bit, fUpTestValue[bit],fLowTestValue[AliQAv1::kINFO],histonumb,steprange[bit] );
445 }
446 //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]));
447}
448
449
450//_____________________________________________________________________________
451void AliITSQAChecker::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
452{
9b94f977 453 //Setting of the QA tolerance values
80b9610c 454 AliQAv1 * qa = AliQAv1::Instance(index) ;
455
456
457 for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
458
459 if (! qa->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)))
460 continue ;
461 if ( value == NULL ) { // No checker is implemented, set all QA to Fatal
462 qa->Set(AliQAv1::kFATAL, specie) ;
463 } else {
464 if ( value[specie] > fLowTestValue[AliQAv1::kFATAL] && value[specie] <= fUpTestValue[AliQAv1::kFATAL] )
465 qa->Set(AliQAv1::kFATAL, AliRecoParam::ConvertIndex(specie)) ;
466 else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] && value[specie] <= fUpTestValue[AliQAv1::kERROR] )
467 qa->Set(AliQAv1::kERROR, AliRecoParam::ConvertIndex(specie)) ;
468 else if ( value[specie] > fLowTestValue[AliQAv1::kWARNING] && value[specie] <= fUpTestValue[AliQAv1::kWARNING] )
469 qa->Set(AliQAv1::kWARNING, AliRecoParam::ConvertIndex(specie)) ;
470 else if ( value[specie] > fLowTestValue[AliQAv1::kINFO] && value[specie] <= fUpTestValue[AliQAv1::kINFO] )
471 qa->Set(AliQAv1::kINFO, AliRecoParam::ConvertIndex(specie)) ;
472 //else if(value[specie]==0) qa->Set(AliQAv1::kFATAL, AliRecoParam::ConvertIndex(specie)) ; //no ckeck has been done
473 }
474 qa->ShowStatus(AliQAv1::kITS,index,AliRecoParam::ConvertIndex(specie));
475 }//end for
476
477}
478
479
8db5c9f9 480//__________________________________________________________________
481void AliITSQAChecker::MakeImage( TObjArray ** list, AliQAv1::TASKINDEX_t task, AliQAv1::MODE_t mode)
482{
9b94f977 483 //make a summary image
8db5c9f9 484 //gStyle->SetPalette(1);
485
486 //Int_t nImages = 0 ;
487 //Int_t imageindex=0;
488 for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
489 if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(esIndex)) )
490 continue ;
491 //else imageindex=esIndex;
492
493 TIter next(list[esIndex]) ;
494 TH1 * hdata = NULL ;
495 while ( (hdata=static_cast<TH1 *>(next())) ) {
496 TString cln(hdata->ClassName()) ;
497 if ( ! cln.Contains("TH") )
498 continue ;
a6a921e0 499 if(cln.Contains("TH2"))
500 {
501 Float_t min=hdata->GetMinimum();
502 Float_t max=hdata->GetMaximum();
503 if(max>min) hdata->SetOption("colz");
504 }
8db5c9f9 505 }
506 break ;
507 }
508
509 Bool_t retvalue=kFALSE;
510
511 if(GetSubDet()==0) MakeITSImage(list,task, mode);
512 else if(GetSubDet()==1)
513 {
514 retvalue=fSPDChecker->MakeSPDImage(list,task, mode) ;
515 if(retvalue==kFALSE)AliQACheckerBase::MakeImage(list,task, mode);
516 }
517 else if(GetSubDet()==2){ retvalue=fSDDChecker->MakeSDDImage(list,task, mode) ;if(retvalue==kFALSE)AliQACheckerBase::MakeImage(list,task,mode); }
518 else if(GetSubDet()==3)
519 {
520 retvalue=fSSDChecker->MakeSSDImage(list,task, mode) ;
521 if(retvalue==kFALSE)AliQACheckerBase::MakeImage(list,task, mode);
522 }
523
524}
525