The volumes that were still coded in the Geant3 framework have been redefined within...
[u/mrichter/AliRoot.git] / ITS / AliITSQASDDChecker.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 //  P. Cerello Apr 2008
22 //  INFN Torino
23
24 // --- ROOT system ---
25 #include "TH1.h"
26 #include <TH1D.h>
27 #include <TH2.h>
28 #include "TCanvas.h"
29 #include "TPaveText.h"
30 #include "TPad.h"
31 //#include "TPaletteAxis.h"
32 // --- AliRoot header files ---
33 #include "AliITSQADataMakerRec.h"
34 #include "AliITSQASDDChecker.h"
35 #include "AliLog.h"
36 #include "AliCDBEntry.h"
37 #include "AliCDBManager.h"
38 #include "AliITSCalibrationSDD.h"
39 #include "AliITSgeomTGeo.h"
40 #include "AliQAManager.h"
41 #include "AliQAv1.h"
42 #include "AliQAChecker.h"
43 #include "AliQACheckerBase.h"
44
45
46 ClassImp(AliITSQASDDChecker)
47 //__________________________________________________________________
48 AliITSQASDDChecker& AliITSQASDDChecker::operator = (const AliITSQASDDChecker& qac ) 
49 {
50   // Equal operator.
51   this->~AliITSQASDDChecker();
52   new(this) AliITSQASDDChecker(qac);
53   return *this;
54 }
55
56 AliITSQASDDChecker::~AliITSQASDDChecker() 
57 {
58
59   //destructor
60   if(fStepBitSDD) 
61     {
62       delete[] fStepBitSDD ;
63       fStepBitSDD = NULL;
64     }
65   if(fLowSDDValue)
66     {
67       delete[]fLowSDDValue;
68       fLowSDDValue=NULL;
69     }
70   if(fHighSDDValue)
71     { 
72       delete[]fHighSDDValue;
73       fHighSDDValue=NULL;
74     }
75   if(fCalibration)
76     {
77       delete fCalibration;
78       fCalibration=NULL;
79     }
80   if(fImage)
81     {
82       delete []fImage; 
83       fImage=NULL;
84     }
85 } // dtor
86
87 //__________________________________________________________________
88 Double_t AliITSQASDDChecker::Check(AliQAv1::ALITASK_t index, const TObjArray * list, const AliDetectorRecoParam * /*recoparam*/) 
89 {
90   //check histograms of the different lists  
91   AliInfo(Form("AliITSQASDDChecker called with offset: %d\n", fSubDetOffset) );
92
93   AliDebug(1,Form("AliITSQASDDChecker called with offset: %d\n", fSubDetOffset));
94
95   Double_t SDDQACheckerValue = 0.;
96   TH1 *hdata=NULL;
97   Double_t entries=0.;
98   Double_t entries2[2];
99   for(Int_t i=0;i<2;i++)entries2[i]=0.;
100
101   if(!fCalibration){
102     AliCDBEntry *calibSDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD");
103     Bool_t cacheStatus = AliCDBManager::Instance()->GetCacheFlag();
104     if(!calibSDD)
105       {
106         AliError("Calibration object retrieval failed! SDD will not be processed");
107         fCalibration = NULL;
108         SDDQACheckerValue= fHighSDDValue[AliQAv1::kWARNING];
109       }
110     else{
111       fCalibration = (TObjArray *)calibSDD->GetObject();
112       
113       if(!cacheStatus)calibSDD->SetObject(NULL);
114       calibSDD->SetOwner(kTRUE);
115       if(!cacheStatus)
116         {
117           delete calibSDD;
118         }
119     }//end calibsdd 
120   }//end f calibration
121
122   AliInfo("Calib SDD Created\n ");
123
124   TIter next(list);
125
126   switch(index) {
127     case AliQAv1::kRAW:{
128       AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
129 //       if(fRawModulePattern) { delete fRawModulePattern; fRawModulePattern = 0; }
130 //       if(fRawL3Pattern) { delete fRawL3Pattern; fRawL3Pattern = 0; }
131 //       if(fRawL4Pattern) { delete fRawL4Pattern; fRawL4Pattern = 0; }
132       if (list->GetEntries() == 0){SDDQACheckerValue += fHighSDDValue[AliQAv1::kFATAL]; break;}
133       TH1 *hmodule=NULL;
134       TH2 *hlayer[2]; 
135       hdata=NULL;
136       Int_t emptymodules[2], filledmodules[2],emptyladders[2],filledladders[2];
137       for(Int_t i=0;i<2;i++){emptymodules[i]=0; filledmodules[i]=0; emptyladders[i]=0; filledladders[i]=0; }
138       for(Int_t i=0;i<2;i++)hlayer[i]=NULL;   
139       while( (hdata = dynamic_cast<TH1* >(next())) ){
140         if (hdata){TString hname=hdata->GetName();
141           if(hname.Contains("SDDchargeMap"))continue;
142           if(hname.Contains("SDDModPattern")){
143             if(hname.Contains("NORM")) continue;
144             hmodule=(TH1*)hdata->Clone();
145             entries= hdata->GetEntries();
146             if(AliITSQADataMakerRec::AreEqual(entries,0.)){AliWarning(Form("===================>>>>>> No entries in  %s \n",hname.Data()));SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];}//endif entries
147             else{int modmax=hdata->GetNbinsX();
148               Int_t empty=0;
149               Int_t filled=0;
150               Double_t content=0;
151               for(Int_t i=1;i<=modmax;i++){content=hdata->GetBinContent(i);if(AliITSQADataMakerRec::AreEqual(content,0.)) empty++; else filled++; }//end for
152               AliInfo(Form(" %s : empty modules %i \t filled modules %i",hname.Data(), empty, filled));}//end else pattern entries !=0
153           }             
154           if(hname.Contains("_RelativeOccupancy")) {
155             //fRawModulePattern = (TH1F *) hdata;
156             Float_t threshold = hdata->GetMean() + 4*hdata->GetRMS();
157             if(hname.Contains("L3")) AliInfo(Form("SDD check number 1: L3 mean: %f, rms: ,%f",hdata->GetMean(),hdata->GetRMS()));
158             if(hname.Contains("L4")) AliInfo(Form("SDD check number 2: L4 mean: %f, rms: ,%f",hdata->GetMean(),hdata->GetRMS()));
159             Int_t aboveThreshold = 0;
160             for(Int_t k=0; k<= hdata->GetNbinsX(); k++) {if(hdata->GetBinLowEdge(k) > threshold) aboveThreshold += (int)(hdata->GetBinContent(k));}
161             Float_t fractionAboveThreshold = ((Float_t) aboveThreshold)/hdata->GetEntries();
162             if(hname.Contains("L3")) AliInfo(Form("SDD check number 1, L3: Raw fractionAboveThreshold: %f",fractionAboveThreshold));
163             if(hname.Contains("L4")) AliInfo(Form("SDD check number 2, L4: Raw fractionAboveThreshold: %f",fractionAboveThreshold));
164             if(fractionAboveThreshold > fThresholdForRelativeOccupancy) {SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
165               if(hname.Contains("L3")) AliInfo(Form("SDD check number 1: Set Warning (L3 Raw)"));
166               if(hname.Contains("L4")) AliInfo(Form("SDD check number 2: Set Warning (L4 Raw)")); } }
167           if(hname.Contains("SDDphizL3") || hname.Contains("SDDphizL4")){if(hname.Contains("NORM"))continue;
168             //if(hname.Contains("L3")) {fRawL3Pattern = (TH2F *) hdata;}
169             //if(hname.Contains("L4")) {fRawL4Pattern = (TH2F *) hdata;}
170             Int_t layer=0;
171             if(hname.Contains("3"))layer=0;
172             else  if(hname.Contains("4"))layer=1;
173             entries2[layer]=hdata->GetEntries();
174             if(entries2[layer]==0){AliWarning(Form("===================>>>>>> No entries in  %s \n",hname.Data()));
175               SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];}//end if getentries
176             else{
177               Int_t layer1=0;
178               if(hname.Contains("3"))layer1=0;
179               else  if(hname.Contains("4"))layer1=1;
180               TH2* htemp=dynamic_cast<TH2*>(hdata);
181               if(htemp){
182                 hlayer[layer1]=(TH2*)htemp->Clone();
183                 hlayer[layer1]->SetName(Form("%s_copy",hname.Data()));
184                 hlayer[layer1]->RebinX(2);
185                 int modmay=hlayer[layer1]->GetNbinsY();
186                 TH1D* hproj= hlayer[layer1]->ProjectionY();
187                 Double_t ladcontent=0;
188                 for(Int_t i=1;i<=modmay;i++) {//loop on the ladders
189                   ladcontent=hproj->GetBinContent(i);
190                   if(AliITSQADataMakerRec::AreEqual(ladcontent,0.)) emptyladders[layer1]++;
191                   else filledladders[layer1]++;}//end for
192                 AliInfo(Form(" %s : empty ladders %i \t filled ladders %i\n",hname.Data(), emptyladders[layer], filledladders[layer]));//end else layer 3
193                 delete hproj;
194                 hproj=NULL;
195               }//end if htemp
196             }//end else entries !=0
197           }//end check on phiz        
198         }//end if hdata 
199       }//end while
200       if(AliITSQADataMakerRec::AreEqual(entries,0.)&&AliITSQADataMakerRec::AreEqual(entries2[0],0.)&&AliITSQADataMakerRec::AreEqual(entries2[1],0.)) break;
201       //else{
202       if(hmodule || (hlayer[0] && hlayer[1])){
203         Int_t excluded=0;
204         Int_t active=0;
205         Int_t exactive=0;//excluded but taking data
206         for(Int_t imod=0;imod<fgknSDDmodules;imod++){
207           Int_t lay=0;
208           Int_t lad=0;
209           Int_t det=0;
210           Int_t module=0;
211           module=imod+fgkmodoffset;
212           AliITSCalibrationSDD * cal=(AliITSCalibrationSDD*)fCalibration->At(imod);
213           if(cal==0) { continue;}
214           AliITSgeomTGeo::GetModuleId(module,lay,lad,det);
215           if (cal->IsBad()){
216             excluded++;
217             Double_t content=0.;
218             Double_t contentlayer[2];
219             for(Int_t i=0;i<2;i++)contentlayer[i]=0.;
220             if(hmodule)content=hmodule->GetBinContent(imod+1);//if expert bit is active the histogram has been created 
221             if(hlayer[lay-3]) contentlayer[lay-3]=hlayer[lay-3]->GetBinContent(det,lad);
222             if(AliITSQADataMakerRec::AreEqual(content,0.)== kFALSE || AliITSQADataMakerRec::AreEqual(contentlayer[lay-3],0.)==kFALSE) {
223               filledmodules[lay-3]++;
224               AliWarning(Form("The module %d (layer %i, ladder %i det %i ) excluded from the acquisition, took data \n ",module,lay,lad,det));
225               exactive++;
226             } else if(AliITSQADataMakerRec::AreEqual(content,0.) && AliITSQADataMakerRec::AreEqual(contentlayer[lay-3],0.)) 
227               emptymodules[lay-3]++;
228           } else {
229             Double_t contentgood=0.;
230             active++;
231             if(hlayer[lay-3]) contentgood=hlayer[lay-3]->GetBinContent(det,lad);
232             if(AliITSQADataMakerRec::AreEqual(contentgood,0.)) 
233               emptymodules[lay-3]++;
234             else 
235               filledmodules[lay-3]++;
236           }
237         }//end for
238         for(Int_t i=0;i<2;i++){AliInfo(Form("Layer %i \tempty modules %i \t filled modules %i\n", i+3,emptymodules[i], filledmodules[i]));}//end else layers
239         if(exactive==0){
240           AliInfo(Form("All the active modules (%i) are in acquisition. The number of excluded modules are %i \n",active,excluded));
241           SDDQACheckerValue=fHighSDDValue[AliQAv1::kINFO];
242         }
243         if(exactive!=0){
244           AliWarning(Form("%i modules excluded from the acquisition took data. Active modules%i \n ",exactive,active));
245           SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
246         }
247         if(excluded==exactive){
248           AliWarning(Form("All the modules excluded from the acquisition (%d) took data!  Active modules %i\n",excluded,active));
249           SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
250         }
251         if(active==0){
252           AliWarning(Form("No modules took data: excluded %i \t exactive %i \n", excluded, exactive)); 
253           SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
254         }
255         
256       }//end else 
257       delete hmodule;
258       hmodule=NULL;
259       for(Int_t i=0;i<2;i++) {
260         delete hlayer[i];
261         hlayer[i]=NULL;
262       }
263
264     }
265       
266       break;
267       
268   case AliQAv1::kNULLTASK:{
269     AliInfo(Form("No Check on %s\n",AliQAv1::GetAliTaskName(index))); 
270     SDDQACheckerValue=1.;
271   }
272     break;
273     
274   case AliQAv1::kREC:
275     {
276       Int_t uidrec=list->GetUniqueID();
277       AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index))); 
278       if(uidrec==20){
279         //recpoints
280         if (list->GetEntries() == 0){ //check if the list is empty
281           //printf("SDDQACheckerValue = %f \t value %f\n",SDDQACheckerValue,fHighSDDValue[AliQAv1::kFATAL]);
282           SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL]; 
283           break;                        
284         }//end if getentries
285       
286         while((hdata=dynamic_cast<TH1* >(next()))){
287           if (hdata){
288             TString hname=hdata->GetName();
289             if(hname.Contains("_RelativeOccupancy")) {
290               Float_t threshold = hdata->GetMean() + 4*hdata->GetRMS();
291               if(hname.Contains("L3")) AliInfo(Form("SDD check number 3: L3 mean: %f, rms: ,%f",hdata->GetMean(),hdata->GetRMS()));
292               if(hname.Contains("L4")) AliInfo(Form("SDD check number 4: L4 mean: %f, rms: ,%f",hdata->GetMean(),hdata->GetRMS()));
293               Int_t aboveThreshold = 0;
294               for(Int_t k=0; k<= ((Int_t)hdata->GetNbinsX()); k++) {
295                 if(hdata->GetBinLowEdge(k) > threshold) aboveThreshold += (Int_t)(hdata->GetBinContent(k));
296               }
297               Float_t fractionAboveThreshold = ((Float_t) aboveThreshold)/hdata->GetEntries();
298               if(hname.Contains("L3")) AliInfo(Form("SDD check number 3, L3: RecPoints fractionAboveThreshold: %f",fractionAboveThreshold));
299               if(hname.Contains("L4")) AliInfo(Form("SDD check number 4, L4: RecPoints fractionAboveThreshold: %f",fractionAboveThreshold));
300               if(fractionAboveThreshold > fThresholdForRelativeOccupancy) { 
301                 SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
302                 if(hname.Contains("L3")) AliInfo(Form("SDD check number 3: Set Warning (L3 RecPoints)"));
303                 if(hname.Contains("L4")) AliInfo(Form("SDD check number 4: Set Warning (L4 RecPoints)"));
304               }
305             }
306             if(hname.Contains("Rec2Raw") && !hname.Contains("2D")) {
307               //Float_t threshold = 0.;
308               if(hname.Contains("L3")) AliInfo(Form("SDD check number 5: L3 R2R mean: %f, rms: ,%f",((TH1F *) hdata)->GetMean(),((TH1F *) hdata)->GetRMS()));
309               if(hname.Contains("L4")) AliInfo(Form("SDD check number 6: L4 R2R mean: %f, rms: ,%f",((TH1F *) hdata)->GetMean(),((TH1F *) hdata)->GetRMS()));
310               Int_t belowThreshold = 0;
311               for(Int_t k=0; k<=((TH1F *)hdata)->GetNbinsX(); k++) {
312                 if(((TH1F *) hdata)->GetBinLowEdge(k) < fThresholdForRecToRawRatio) belowThreshold += ((Int_t)((TH1F *) hdata)->GetBinContent(k));
313               }
314               Double_t fractionBelowThreshold =0.;
315               Double_t entries3=((TH1F *)hdata)->GetEntries();
316               if(entries3>0.001)fractionBelowThreshold = ((Double_t)(belowThreshold))/entries3;
317               else{ AliWarning(Form("No entries on %s. The check will retuns zero.\n",hdata->GetName() )); }
318               if(hname.Contains("L3")) AliInfo(Form("SDD check number 5, L3: RecPoints2Raws fractionBelowThreshold: %f",fractionBelowThreshold));
319               if(hname.Contains("L4")) AliInfo(Form("SDD check number 6, L4: RecPoints2Raws fractionBelowThreshold: %f",fractionBelowThreshold));
320               if(fractionBelowThreshold > fThresholdForRelativeOccupancy) { 
321                 SDDQACheckerValue=fHighSDDValue[AliQAv1::kWARNING];
322                 if(hname.Contains("L3")) AliInfo(Form("SDD check number 5: Set Warning (L3 RecPoints2Raws)"));
323                 if(hname.Contains("L4")) AliInfo(Form("SDD check number 6: Set Warning (L4 RecPoints2Raws)"));
324               }
325             }
326             if(hname.Contains("dedx")) {
327               if(hname.Contains("L3")) AliInfo(Form("SDD check number 7: L3 average charge: %f, rms: ,%f",hdata->GetMean(),hdata->GetRMS()));
328               if(hname.Contains("L4")) AliInfo(Form("SDD check number 8: L4 average charge: %f, rms: ,%f",hdata->GetMean(),hdata->GetRMS()));
329             }
330           }
331         }                               
332       
333         SDDQACheckerValue=1.;
334       }
335       else if(uidrec==40)
336         {
337           //digitsr
338           if (list->GetEntries() == 0){ 
339             SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
340             break;
341           } else{
342         
343             while( (hdata = dynamic_cast<TH1* >(next())) ){
344               if (hdata){
345                 if(hdata->GetEntries()==0)SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];
346                 else {
347                   TString hname=hdata->GetName();
348                   if(hname.Contains("SDD DIGITS Module Pattern")) {
349                     //see raws
350                 
351                     SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
352                   } else if(hname.Contains("SDD Anode Distribution")) {
353                     SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
354                   } else if(hname.Contains("SDD Tbin Distribution")) {
355                     //to do as rp
356                     SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
357                   } else if(hname.Contains("SDD ADC Counts Distribution")) {
358                     SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
359                   }//end adc counts
360               
361                 }//end entries !=0
362               }//end hdata
363             }//end while
364           }//end else
365           SDDQACheckerValue=1.;
366         }
367
368     }
369     break;
370   case AliQAv1::kANA:
371     {
372       AliInfo(Form("===================> No Check on %s\n",AliQAv1::GetAliTaskName(index)));
373       SDDQACheckerValue=1.; 
374     }
375     break;
376   case AliQAv1::kESD:
377     {
378       AliInfo(Form("==================>  No Check on %s\n",AliQAv1::GetAliTaskName(index)));
379       SDDQACheckerValue=1.;
380     } 
381     break;
382   case AliQAv1::kNTASK:{
383     AliInfo(Form("==================>  No Check on %s\n",AliQAv1::GetAliTaskName(index))); 
384     SDDQACheckerValue=1.;
385   }
386     break;
387   case AliQAv1::kSIM:{
388     AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index))); 
389     Int_t uid=list->GetUniqueID();
390     if(uid==60) {
391       //digits
392       if (list->GetEntries() == 0){ 
393         SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
394         break;
395       } else{
396         
397         while( (hdata = dynamic_cast<TH1* >(next())) ){
398           if (hdata){
399             if(hdata->GetEntries()==0)SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];
400             else {
401               TString hname=hdata->GetName();
402               if(hname.Contains("SDDDIGITSModulePattern")) {
403                 //see raws
404                 
405                 SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
406               } else if(hname.Contains("SDDAnodeDistribution")) {
407                 SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
408               } else if(hname.Contains("SDDTbinDistribution")) {
409                 //to do as rp
410                 SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
411               } else if(hname.Contains("SDDADCCountsDistribution")) {
412                 SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
413               }//end adc counts
414               
415             }//end entries !=0
416           }//end hdata
417         }//end while
418       }//end else
419     } else if(uid==50) 
420       {
421         //hits
422         if (list->GetEntries() == 0){ 
423           SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
424           break;
425         } 
426         else{
427           
428           while( (hdata = dynamic_cast<TH1* >(next())) ){
429             if (hdata){
430               if(hdata->GetEntries()==0)SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];
431               else {
432                 TString hname=hdata->GetName();
433                 if(hname.Contains("SDDHITSModulePattern")) {
434                   //to do as raws
435                   SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
436                 } else if(hname.Contains("SDDHITlenghtalonglocalYCoord")) {
437                   SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
438                 } else if(hname.Contains("SDDHITlenghtalonglocalYCoordZoom")) {
439                   SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
440                 } else if(hname.Contains("SDDDepositedEnergyDistribution")) {
441                   SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
442                 }//end deposited energy
443                 
444               }//end entries !=0
445             }//end hdata
446           }//end while
447         }//end else
448       } else if(uid==70) 
449       {
450         //sdigits
451         if (list->GetEntries() == 0){ 
452           SDDQACheckerValue=fHighSDDValue[AliQAv1::kFATAL];
453           break;
454         } else{
455           
456           while( (hdata = dynamic_cast<TH1* >(next())) ){
457             if (hdata){
458               if(hdata->GetEntries()==0)SDDQACheckerValue += fStepBitSDD[AliQAv1::kFATAL];
459               else {
460                 TString hname=hdata->GetName();
461                 if(hname.Contains("SDDSDIGITSModulePattern")) {
462                   //to do as raws
463                   SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
464                 } else if(hname.Contains("SDDAnodeDistribution")) {
465                   SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
466                 } else if(hname.Contains("SDDTbinDistribution")) {
467                   //to do as rp
468                   SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
469                 } else if(hname.Contains("SDDADCCountsDistribution")) {
470                   SDDQACheckerValue += fStepBitSDD[AliQAv1::kINFO];    
471                 }//end adc counts bindistribution
472               }//end entries !=0
473             }//end hdata
474           }//end while
475         }//end else
476       }//end sdigits
477     SDDQACheckerValue=1.;
478   }
479     break;
480     
481   }//end switch
482   
483   fCalibration=NULL;
484   if(hdata) delete hdata;
485
486
487   return SDDQACheckerValue;     
488 }
489
490 //__________________________________________________________________
491 void AliITSQASDDChecker::SetTaskOffset(Int_t taskoffset)
492 {
493   //set the number of the histograms already present in the list before the SDD histograms
494   fSubDetOffset = taskoffset;
495 }
496
497
498 //__________________________________________________________________
499 void AliITSQASDDChecker::SetStepBit(const Double_t *steprange)
500 {
501   //set the values of the step bit for each QA bit range calculated in the AliITSQAChecker class
502   fStepBitSDD = new Double_t[AliQAv1::kNBIT];
503   for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
504     {
505       fStepBitSDD[bit]=steprange[bit];
506     }
507 }
508
509 //__________________________________________________________________
510 void  AliITSQASDDChecker::SetSDDLimits(const Float_t *lowvalue, const Float_t * highvalue)
511 {
512   //set the low and high values in for each QA bit range calculated in the AliITSQAChecker class
513   fLowSDDValue = new Float_t[AliQAv1::kNBIT];
514   fHighSDDValue= new Float_t[AliQAv1::kNBIT];
515
516   for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
517     {
518       fLowSDDValue[bit]=lowvalue[bit];
519       fHighSDDValue[bit]= highvalue[bit];
520     }
521
522 }
523 //__________________________________________________________________
524 Bool_t  AliITSQASDDChecker::MakeSDDImage( TObjArray ** list, AliQAv1::TASKINDEX_t task, AliQAv1::MODE_t mode)
525 {
526   Bool_t rval=kFALSE;
527   fImage=(TCanvas**)AliQAChecker::Instance()->GetDetQAChecker(0)->GetImage();
528   //create the image for raws and recpoints. In the other case, the default methodof CheckerBase class will be used
529   switch(task)
530     {
531     case AliQAv1::kRAWS:{
532       rval=MakeSDDRawsImage(list, task,mode);
533     }
534       break;
535     case AliQAv1::kRECPOINTS:{ rval=MakeSDDRecPointsImage(list, task,mode); }
536       break;
537     case AliQAv1::kHITS:; case AliQAv1::kESDS:; case AliQAv1::kDIGITS:;case AliQAv1::kDIGITSR:;case AliQAv1::kSDIGITS:;case AliQAv1::kTRACKSEGMENTS:;case AliQAv1::kRECPARTICLES:; default:
538     {
539        rval=kFALSE;
540        //AliQAChecker::Instance()->GetDetQAChecker(0)->MakeImage(list,task,mode);
541     }
542     break;
543     case AliQAv1::kNULLTASKINDEX:; case  AliQAv1::kNTASKINDEX: 
544       {AliWarning(Form("No histograms for this task ( %s ) \n", AliQAv1::GetTaskName(task).Data())); rval=kFALSE;}
545       break;
546     }
547 return rval;  
548 }
549
550
551 //_______________________________________________________________________
552 Bool_t AliITSQASDDChecker::MakeSDDRawsImage(TObjArray ** list, AliQAv1::TASKINDEX_t task, AliQAv1::MODE_t mode )
553 {
554
555     for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
556       //printf("-------------------------> %i \n", esIndex);
557       if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(esIndex)) || list[esIndex]->GetEntries() == 0) 
558           {//printf ("Nothing for %s \n", AliRecoParam::GetEventSpecieName(esIndex));
559          continue;
560         }
561       else{
562         const Char_t * title = Form("QA_%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(esIndex)) ; 
563         if ( !fImage[esIndex] ) {
564           fImage[esIndex] = new TCanvas(title, title,1280,980) ;
565         }
566         
567         fImage[esIndex]->Clear() ; 
568         fImage[esIndex]->SetTitle(title) ; 
569         fImage[esIndex]->cd();
570  
571         TPaveText someText(0.015, 0.015, 0.98, 0.98);
572         someText.AddText(title);
573         someText.Draw(); 
574         fImage[esIndex]->Print(Form("%s%s%d.%s", AliQAv1::GetImageFileName(), AliQAv1::GetModeName(mode), AliQAChecker::Instance()->GetRunNumber(), AliQAv1::GetImageFileFormat()), "ps") ; 
575         fImage[esIndex]->Clear() ; 
576         Int_t nx =2; //TMath::Nint(TMath::Sqrt(nImages));
577         Int_t ny =1; // nx  ; 
578         //if (nx < TMath::Sqrt(nImages))
579         //ny++ ;  
580         fImage[esIndex]->Divide(nx, ny) ; 
581         TIter nexthist(list[esIndex]) ; 
582         TH1* hist = NULL ;
583         Int_t npad = 1 ; 
584         fImage[esIndex]->cd(npad); 
585         fImage[esIndex]->cd(npad)->SetBorderMode(0) ;
586         while ( (hist=static_cast<TH1*>(nexthist())) ) {
587           //gPad=fImage[esIndex]->cd(npad)->GetPad(npad);
588           TString cln(hist->ClassName()) ; 
589           if ( ! cln.Contains("TH") )
590             continue ;
591           
592           if(hist->TestBit(AliQAv1::GetImageBit())) {
593             hist->GetXaxis()->SetTitleSize(0.02);
594             hist->GetYaxis()->SetTitleSize(0.02);
595             hist->GetXaxis()->SetLabelSize(0.02);
596             hist->GetYaxis()->SetLabelSize(0.02);
597             if(cln.Contains("TH2"))
598               {
599                 gPad->SetRightMargin(0.15);
600                 gPad->SetLeftMargin(0.05);
601                 hist->SetStats(0);
602                 hist->SetOption("colz") ;
603                 //hist->GetListOfFunctions()->FindObject("palette")->SetLabelSize(0.025);
604                 //gPad->Update();
605               }
606             hist->DrawCopy() ; 
607             fImage[esIndex]->cd(++npad) ; 
608             fImage[esIndex]->cd(npad)->SetBorderMode(0) ; 
609           }
610         }
611         fImage[esIndex]->Print(Form("%s%s%d.%s", AliQAv1::GetImageFileName(), AliQAv1::GetModeName(mode), AliQAChecker::Instance()->GetRunNumber(), AliQAv1::GetImageFileFormat()), "ps") ; 
612       }
613     }
614    return kTRUE;
615 }
616
617
618
619
620 //_______________________________________________________________________
621 Bool_t AliITSQASDDChecker::MakeSDDRecPointsImage(TObjArray ** list, AliQAv1::TASKINDEX_t task, AliQAv1::MODE_t mode )
622 {
623
624     for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
625       if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(esIndex)) || list[esIndex]->GetEntries() == 0) 
626         {
627         //printf ("Nothing for %s \n", AliQAv1::GetTaskName(task).Data()); 
628         continue;
629         }
630       const Char_t * title = Form("QA_%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(esIndex)) ; 
631       if ( !fImage[esIndex] ) {
632         fImage[esIndex] = new TCanvas(title, title,1280,980) ;
633       }
634       fImage[esIndex]->Clear() ; 
635       fImage[esIndex]->SetTitle(title) ; 
636       fImage[esIndex]->cd();
637       fImage[esIndex]->SetBorderMode(0) ;  
638       TPaveText someText(0.015, 0.015, 0.98, 0.98);
639       someText.AddText(title);
640       someText.Draw(); 
641       fImage[esIndex]->Print(Form("%s%s%d.%s", AliQAv1::GetImageFileName(), AliQAv1::GetModeName(mode), AliQAChecker::Instance()->GetRunNumber(), AliQAv1::GetImageFileFormat()), "ps") ; 
642       fImage[esIndex]->Clear() ; 
643       Int_t nx =2; //TMath::Nint(TMath::Sqrt(nImages));
644       Int_t ny =4; // nx  ; 
645       //if (nx < TMath::Sqrt(nImages))
646       //ny++ ;  
647       fImage[esIndex]->Divide(nx, ny) ; 
648       TIter nexthist(list[esIndex]) ; 
649       TH1* hist = NULL ;
650       Int_t npad = 1 ; 
651       fImage[esIndex]->cd(npad) ; 
652       fImage[esIndex]->cd(npad)->SetBorderMode(0) ; 
653       while ( (hist=static_cast<TH1*>(nexthist())) ) {
654         //gPad=fImage[esIndex]->cd(npad)->GetPad(npad);
655         TString cln(hist->ClassName()) ;
656         //printf("=====================> Class name %s \n",cln.Data()); 
657         if ( ! cln.Contains("TH") )
658           continue ;
659         if(hist->TestBit(AliQAv1::GetImageBit())) {
660             hist->GetXaxis()->SetTitleSize(0.02);
661             hist->GetYaxis()->SetTitleSize(0.02);
662             hist->GetXaxis()->SetLabelSize(0.02);
663             hist->GetYaxis()->SetLabelSize(0.02);
664           if(cln.Contains("TH1"))
665             {
666               hist->SetFillColor(kOrange+7);
667               //SetFrameFillColor(kAzure-9);
668               //hist->DrawCopy() ; 
669             }
670           if(cln.Contains("TH2"))
671             {
672               gPad->SetRightMargin(0.15);
673               gPad->SetLeftMargin(0.05);
674               hist->SetStats(0);
675               hist->SetOption("colz") ;
676               //              TPaletteAxis *paletta =(TPaletteAxis*)hist->GetListOfFunctions()->FindObject("palette");
677               //paletta->SetLabelSize(0.025);
678               //gPad->Update(); 
679             }
680           hist->DrawCopy();
681           fImage[esIndex]->cd(++npad) ; 
682           fImage[esIndex]->cd(npad)->SetBorderMode(0) ; 
683         }
684       }
685       fImage[esIndex]->Print(Form("%s%s%d.%s", AliQAv1::GetImageFileName(), AliQAv1::GetModeName(mode), AliQAChecker::Instance()->GetRunNumber(), AliQAv1::GetImageFileFormat()), "ps") ; 
686     }
687     // }  
688    return kTRUE;
689 }