Line data Source code
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 118 : ClassImp(AliITSQAChecker)
37 :
38 : //____________________________________________________________________________
39 : AliITSQAChecker::AliITSQAChecker(Bool_t kMode, Short_t subDet, Short_t ldc) :
40 3 : AliQACheckerBase("ITS","SDD Quality Assurance Checker"),
41 3 : fkOnline(0),
42 3 : fDet(0),
43 3 : fLDC(0),
44 3 : fSPDOffset(0),
45 3 : fSDDOffset(0),
46 3 : fSSDOffset(0),
47 3 : fSPDHisto(0),
48 3 : fSDDHisto(0),
49 3 : fSSDHisto(0),
50 3 : fSPDChecker(0), // SPD Checker
51 3 : fSDDChecker(0), // SDD Checker
52 3 : fSSDChecker(0) // SSD Checker
53 :
54 9 : {
55 : // Standard constructor
56 3 : fkOnline = kMode; fDet = subDet; fLDC = ldc;
57 3 : if(fDet == 0 || fDet == 1) {
58 15 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SPD Checker\n");
59 9 : fSPDChecker = new AliITSQASPDChecker();
60 3 : }
61 3 : if(fDet == 0 || fDet == 2) {
62 15 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SDD Checker\n");
63 9 : fSDDChecker = new AliITSQASDDChecker();
64 3 : }
65 3 : if(fDet == 0 || fDet == 3) {
66 15 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SSD Checker\n");
67 9 : fSSDChecker = new AliITSQASSDChecker();
68 3 : }
69 3 : InitQACheckerLimits();
70 6 : }
71 :
72 : //____________________________________________________________________________
73 0 : AliITSQAChecker::~AliITSQAChecker(){
74 : // destructor
75 0 : if(fSPDChecker)delete fSPDChecker;
76 0 : if(fSDDChecker)delete fSDDChecker;
77 0 : if(fSSDChecker)delete fSSDChecker;
78 :
79 0 : }
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 0 : if(index == AliQAv1::kESD){
88 :
89 0 : for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
90 0 : rv[specie] = 0.0 ;
91 0 : if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
92 : continue ;
93 0 : 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 0 : if (list[specie]->GetEntries() == 0) {
104 0 : rv[specie] = 0.; // nothing to check
105 0 : }
106 : else {
107 0 : Double_t stepbit[AliQAv1::kNBIT];
108 0 : Double_t histonumb= list[specie]->GetEntries();
109 0 : CreateStepForBit(histonumb,stepbit);
110 0 : TIter next1(list[specie]);
111 : TH1 * hdata;
112 : Int_t nskipped=0;
113 0 : Bool_t skipped[6]={kFALSE,kFALSE,kFALSE,kFALSE,kFALSE,kFALSE};
114 : // look for layers that we wanted to skip
115 0 : while ( (hdata = dynamic_cast<TH1 *>(next1())) ) {
116 0 : if(hdata){
117 0 : TString hname = hdata->GetName();
118 0 : if(!hname.Contains("hESDSkippedLayers")) continue;
119 0 : for(Int_t k=1; k<7; k++) {
120 0 : if(hdata->GetBinContent(k)>0) {
121 0 : nskipped++;
122 0 : skipped[k-1]=kTRUE;
123 0 : }
124 : }
125 0 : }
126 : }
127 0 : TIter next(list[specie]);
128 0 : while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
129 0 : if(hdata){
130 0 : TString hname = hdata->GetName();
131 0 : Double_t entries = hdata->GetEntries();
132 0 : ++tested;
133 0 : if(!(entries>0.))++empty;
134 0 : AliDebug(AliQAv1::GetQADebugLevel(),Form("ESD hist name %s - entries %12.1g",hname.Data(),entries));
135 0 : if(hname.Contains("hESDClusterMapSA") && entries>0.){
136 : cluMapSA = kTRUE;
137 0 : 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 0 : for(Int_t k=1;k<7;k++){
141 : // check if the layer was skipped
142 0 : if(skipped[k-1]) continue;
143 0 : if(hdata->GetBinContent(k)<0.5*(entries/6.)){
144 : cluMapSA = kFALSE;
145 0 : AliDebug(AliQAv1::GetQADebugLevel(),Form("SA tracks have few points on layer %d - look at histogram hESDClustersSA",k));
146 : }
147 : }
148 0 : }//end clustermapsa
149 :
150 0 : else if(hname.Contains("hESDClusterMapMI") && entries>0.){
151 : // Check if there are layers with anomalously low
152 : // contributing points to MI reconstructed tracks
153 0 : AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
154 : cluMapMI = kTRUE;
155 0 : for(Int_t k=1;k<7;k++){
156 : // check if the layer was skipped
157 0 : if(skipped[k-1]) continue;
158 0 : if(hdata->GetBinContent(k)<0.5*(entries/6.)){
159 : cluMapMI = kFALSE;
160 0 : AliDebug(AliQAv1::GetQADebugLevel(),Form("MI tracks have few points on layer %d - look at histogram hESDClustersMI",k));
161 : }
162 : }
163 0 : }//end clustermapmi
164 :
165 0 : else if(hname.Contains("hESDClustersMI") && entries>0.){
166 : // Check if 6 clusters MI tracks are the majority
167 0 : AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
168 : cluMI = kTRUE;
169 0 : Double_t maxlaytracks = hdata->GetBinContent(7-nskipped);
170 0 : for(Int_t k=2; k<7-nskipped; k++){
171 0 : if(hdata->GetBinContent(k)>maxlaytracks){
172 : cluMI = kFALSE;
173 0 : 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 0 : }//end clustersmi
177 :
178 0 : else if(hname.Contains("hESDClustersSA") && entries>0.){
179 : // Check if 6 clusters SA tracks are the majority
180 0 : AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
181 : cluSA = kTRUE;
182 0 : Double_t maxlaytracks = hdata->GetBinContent(7-nskipped);
183 0 : for(Int_t k=2; k<7-nskipped; k++){
184 0 : if(hdata->GetBinContent(k)>maxlaytracks){
185 : cluSA = kFALSE;
186 0 : 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 0 : }//end clusterssa
190 :
191 0 : else if(hname.Contains("hSPDVertexZ") && entries>0.){
192 : // Check if average Z vertex coordinate is -5 < z < 5 cm
193 0 : AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
194 : verSPDZ = kTRUE;
195 0 : if(hdata->GetMean()<-5. && hdata->GetMean()>5.){
196 : verSPDZ = kFALSE;
197 0 : AliDebug(AliQAv1::GetQADebugLevel(),Form("Average z vertex coordinate is at z= %10.4g cm",hdata->GetMean()));
198 : }
199 : }//end spdvertexz
200 :
201 0 : else{ AliError("ESD Checker - invalid data type");}//end else
202 :
203 0 : rv[specie] = 0.;
204 0 : if(tested>0){
205 0 : if(tested == empty){
206 0 : rv[specie] = 2500.; // set to error
207 0 : AliWarning(Form("All ESD histograms are empty - specie=%d",specie));
208 : }
209 : else {
210 0 : rv[specie] = 2500.-1500.*(static_cast<Double_t>(tested-empty)/static_cast<Double_t>(tested)); // INFO if all histos are filled
211 0 : if(cluMapSA)rv[specie]-=200.;
212 0 : if(cluMapMI)rv[specie]-=200.;
213 0 : if(cluMI)rv[specie]-=200.;
214 0 : if(cluSA)rv[specie]-=200.;
215 0 : if(verSPDZ)rv[specie]-=199.; // down to 1 if everything is OK
216 : }
217 : }//end tested
218 0 : }//end hdata
219 : }//end while
220 : // AliDebug(AliQAv1::GetQADebugLevel(), Form("ESD - Tested %d histograms, Return value %f \n",tested,rv[specie]));
221 0 : AliInfo(Form("ESD - Tested %d histograms, Return value %f \n",tested,rv[specie]));
222 0 : }
223 0 : }
224 0 : } // end of ESD QA
225 : else{
226 :
227 : //____________________________________________________________________________
228 :
229 0 : Double_t spdCheck[AliRecoParam::kNSpecies] ;
230 0 : Double_t sddCheck[AliRecoParam::kNSpecies] ;
231 0 : Double_t ssdCheck[AliRecoParam::kNSpecies] ;
232 :
233 :
234 :
235 0 : for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
236 0 : if ( !AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
237 0 : if ( AliQAv1::Instance()->IsEventSpecieSet(specie) ) {
238 0 : Double_t histotot=list[specie]->GetEntries();
239 0 : if(histotot!=0)
240 : {
241 0 : spdCheck[specie]=0.;
242 0 : sddCheck[specie]=0.;
243 0 : ssdCheck[specie]=0.;
244 0 : rv[specie] = 0.0 ;//
245 : //pixel
246 0 : if(fDet == 0 || fDet == 1) {
247 0 : fSPDChecker->SetTaskOffset(fSPDOffset);
248 : //printf("spdoffset = %i \n",fSPDOffset );
249 0 : Double_t histoSPD=double(GetSPDHisto());
250 0 : if(AliITSQADataMakerRec::AreEqual(histoSPD,0)==kFALSE){
251 0 : Double_t *stepSPD=new Double_t[AliQAv1::kNBIT];
252 0 : CreateStepForBit(histoSPD,stepSPD);
253 0 : fSPDChecker->SetStepBit(stepSPD);
254 0 : spdCheck[specie] = fSPDChecker->Check(index, list[specie], recoParam);
255 0 : if(spdCheck[specie]>fUpTestValue[AliQAv1::kFATAL]||spdCheck[specie]<0.)
256 : {
257 0 : 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 0 : spdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];
259 0 : }
260 0 : delete []stepSPD;
261 0 : }//end check SPD entries
262 0 : else{spdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];}
263 0 : rv[specie]=spdCheck[specie];
264 0 : }//end SPD check
265 : //drift
266 0 : if(fDet == 0 || fDet == 2) {
267 0 : fSDDChecker->SetTaskOffset(fSDDOffset);
268 0 : fSDDChecker->SetEventSpecieForCheck(specie);
269 0 : Double_t histoSDD=double(GetSDDHisto());
270 0 : if(AliITSQADataMakerRec::AreEqual(histoSDD,0)==kFALSE){
271 0 : Double_t *stepSDD=new Double_t[AliQAv1::kNBIT];
272 0 : CreateStepForBit(histoSDD,stepSDD);
273 0 : fSDDChecker->SetStepBit(stepSDD);
274 0 : sddCheck[specie] = fSDDChecker->Check(index, list[specie], recoParam);
275 0 : if(sddCheck[specie]>fUpTestValue[AliQAv1::kFATAL]||sddCheck[specie]<0.)
276 : {
277 0 : 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 0 : sddCheck[specie]=fUpTestValue[AliQAv1::kFATAL];
279 0 : }
280 0 : delete []stepSDD;
281 0 : }//end check SDD entries
282 0 : else{ssdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];}
283 0 : if(sddCheck[specie]>rv[specie])rv[specie]=sddCheck[specie];
284 0 : }//end SDD
285 : //strip
286 0 : if(fDet == 0 || fDet == 3) {
287 0 : fSSDChecker->SetTaskOffset(fSSDOffset);
288 0 : Double_t histoSSD=double(GetSSDHisto());
289 0 : if(AliITSQADataMakerRec::AreEqual(histoSSD,0)==kFALSE){
290 0 : Double_t *stepSSD=new Double_t[AliQAv1::kNBIT];
291 0 : CreateStepForBit(histoSSD,stepSSD);
292 0 : fSSDChecker->SetStepBit(stepSSD);
293 0 : ssdCheck[specie] = fSSDChecker->Check(index, list[specie], recoParam);
294 0 : if(ssdCheck[specie]>fUpTestValue[AliQAv1::kFATAL]||ssdCheck[specie]<0.)
295 : {
296 0 : 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 0 : ssdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];
298 0 : }
299 0 : delete [] stepSSD;
300 0 : }//end check SSD entries
301 0 : else{ssdCheck[specie]=fUpTestValue[AliQAv1::kFATAL];}
302 0 : if(ssdCheck[specie]>rv[specie])rv[specie]=ssdCheck[specie];
303 0 : }//end SSD
304 :
305 0 : 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 0 : }//end entries
309 0 : }//end if event specie
310 : }//end for
311 0 : }
312 0 : }
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 0 : fSPDOffset = SPDOffset;
319 0 : fSDDOffset = SDDOffset;
320 0 : fSSDOffset = SSDOffset;
321 0 : }
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 0 : fSPDHisto = SPDhisto;
328 0 : fSDDHisto = SDDhisto;
329 0 : fSSDHisto = SSDhisto;
330 0 : }
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 0 : switch(subdet){
337 : case 1:
338 0 : SetSPDTaskOffset(offset);
339 0 : break;
340 : case 2:
341 0 : SetSDDTaskOffset(offset);
342 0 : break;
343 : case 3:
344 0 : SetSSDTaskOffset(offset);
345 0 : break;
346 : default:
347 0 : AliWarning("No specific (SPD,SDD or SSD) subdetector correspond to to this number!!! all offsets set to zero for all the detectors\n");
348 0 : SetTaskOffset(0, 0, 0);
349 0 : break;
350 : }
351 0 : }
352 :
353 : //____________________________________________________________________________
354 : void AliITSQAChecker::SetDetHisto(Int_t subdet,Int_t histo)
355 : {
356 : //set the number od histograms for the subdetector
357 0 : switch(subdet){
358 : case 1:
359 0 : SetSPDHisto(histo);
360 0 : break;
361 : case 2:
362 0 : SetSDDHisto(histo);
363 0 : break;
364 : case 3:
365 0 : SetSSDHisto(histo);
366 0 : break;
367 : default:
368 0 : AliWarning("No specific (SPD,SDD or SSD) subdetector correspond to to this number!!! all offsets set to zero for all the detectors\n");
369 0 : SetHisto(0, 0, 0);
370 0 : break;
371 : }
372 0 : }
373 :
374 : //_____________________________________________________________________________
375 :
376 : void AliITSQAChecker::InitQACheckerLimits()
377 : {
378 : //init the tolerance range for each QA bit
379 6 : AliInfo("Setting of tolerance values\n");
380 :
381 3 : Float_t lowtolerancevalue[AliQAv1::kNBIT];
382 :
383 3 : Float_t hightolerancevalue[AliQAv1::kNBIT];
384 30 : for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
385 : {
386 12 : lowtolerancevalue[bit]=(bit*1000.);
387 12 : hightolerancevalue[bit]=((bit+1.)*1000.);
388 : }
389 3 : 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 3 : if(fDet == 0 || fDet == 1) {
393 3 : fSPDChecker->SetSPDLimits( lowtolerancevalue,hightolerancevalue );
394 3 : }
395 3 : if(fDet == 0 || fDet == 2) {
396 3 : fSDDChecker->SetSDDLimits( lowtolerancevalue,hightolerancevalue );
397 3 : }
398 3 : if(fDet == 0 || fDet == 3) {
399 3 : fSSDChecker->SetSSDLimits( lowtolerancevalue,hightolerancevalue );
400 3 : }
401 :
402 :
403 :
404 3 : }
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 0 : 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 0 : 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 0 : }
420 :
421 :
422 : //_____________________________________________________________________________
423 : void AliITSQAChecker::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
424 : {
425 : //Setting of the QA tolerance values
426 0 : AliQAv1 * qa = AliQAv1::Instance(index) ;
427 :
428 :
429 0 : for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
430 :
431 0 : if (! qa->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)))
432 : continue ;
433 0 : if ( value == NULL ) { // No checker is implemented, set all QA to Fatal
434 0 : qa->Set(AliQAv1::kFATAL, specie) ;
435 0 : } else {
436 0 : if ( value[specie] > fLowTestValue[AliQAv1::kFATAL] && value[specie] <= fUpTestValue[AliQAv1::kFATAL] )
437 0 : qa->Set(AliQAv1::kFATAL, AliRecoParam::ConvertIndex(specie)) ;
438 0 : else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] && value[specie] <= fUpTestValue[AliQAv1::kERROR] )
439 0 : qa->Set(AliQAv1::kERROR, AliRecoParam::ConvertIndex(specie)) ;
440 0 : else if ( value[specie] > fLowTestValue[AliQAv1::kWARNING] && value[specie] <= fUpTestValue[AliQAv1::kWARNING] )
441 0 : qa->Set(AliQAv1::kWARNING, AliRecoParam::ConvertIndex(specie)) ;
442 0 : else if ( value[specie] > fLowTestValue[AliQAv1::kINFO] && value[specie] <= fUpTestValue[AliQAv1::kINFO] )
443 0 : 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 0 : qa->ShowStatus(AliQAv1::kITS,index,AliRecoParam::ConvertIndex(specie));
447 0 : }//end for
448 :
449 0 : }
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 0 : for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
461 0 : if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(esIndex)) )
462 : continue ;
463 : //else imageindex=esIndex;
464 :
465 0 : TIter next(list[esIndex]) ;
466 : TH1 * hdata = NULL ;
467 0 : while ( (hdata=static_cast<TH1 *>(next())) ) {
468 0 : TString cln(hdata->ClassName()) ;
469 0 : if ( ! cln.Contains("TH") )
470 0 : continue ;
471 0 : if(cln.Contains("TH2"))
472 : {
473 0 : Float_t min=hdata->GetMinimum();
474 0 : Float_t max=hdata->GetMaximum();
475 0 : if(max>min) hdata->SetOption("colz");
476 0 : }
477 0 : }
478 : break ;
479 0 : }
480 :
481 : Bool_t retvalue=kFALSE;
482 :
483 0 : if(GetSubDet()==0) MakeITSImage(list,task, mode);
484 0 : else if(GetSubDet()==1)
485 : {
486 0 : retvalue=fSPDChecker->MakeSPDImage(list,task, mode) ;
487 0 : if(retvalue==kFALSE)AliQACheckerBase::MakeImage(list,task, mode);
488 : }
489 0 : else if(GetSubDet()==2){ retvalue=fSDDChecker->MakeSDDImage(list,task, mode) ;if(retvalue==kFALSE)AliQACheckerBase::MakeImage(list,task,mode); }
490 0 : else if(GetSubDet()==3)
491 : {
492 0 : retvalue=fSSDChecker->MakeSSDImage(list,task, mode) ;
493 0 : if(retvalue==kFALSE)AliQACheckerBase::MakeImage(list,task, mode);
494 : }
495 :
496 0 : }
497 :
|
