RC12, RC17 violation: suppression
[u/mrichter/AliRoot.git] / ITS / AliITSQASDDChecker.cxx
1
2 /**************************************************************************
3  * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
4  *                                                                        *
5  * Author: The ALICE Off-line Project.                                    *
6  * Contributors are mentioned in the code where appropriate.              *
7  *                                                                        *
8  * Permission to use, copy, modify and distribute this software and its   *
9  * documentation strictly for non-commercial purposes is hereby granted   *
10  * without fee, provided that the above copyright notice appears in all   *
11  * copies and that both the copyright notice and this permission notice   *
12  * appear in the supporting documentation. The authors make no claims     *
13  * about the suitability of this software for any purpose. It is          *
14  * provided "as is" without express or implied warranty.                  *
15  **************************************************************************/
16
17 /* $Id$ */
18
19 // *****************************************
20 //  Checks the quality assurance 
21 //  by comparing with reference data
22 //  P. Cerello Apr 2008
23 //  INFN Torino
24
25 // --- ROOT system ---
26 #include "TH1.h"
27 #include <TCanvas.h>
28 #include <TH1D.h>
29 #include <TH2.h>
30 #include <TF1.h>
31
32
33
34 // --- AliRoot header files ---
35 #include "AliITSQASDDChecker.h"
36 #include "AliLog.h"
37 #include "AliCDBEntry.h"
38 #include "AliQAManager.h"
39 #include "AliQACheckerBase.h"
40 #include "TSystem.h"
41 #include "AliITSCalibrationSDD.h"
42 #include "AliITSgeomTGeo.h"
43
44 ClassImp(AliITSQASDDChecker)
45 //__________________________________________________________________
46 AliITSQASDDChecker& AliITSQASDDChecker::operator = (const AliITSQASDDChecker& qac ) 
47 {
48   // Equal operator.
49   this->~AliITSQASDDChecker();
50   new(this) AliITSQASDDChecker(qac);
51   return *this;
52 }
53
54 AliITSQASDDChecker::~AliITSQASDDChecker() 
55 {
56   if(fStepBitSDD) 
57     {
58       delete[] fStepBitSDD ;
59       fStepBitSDD = NULL;
60     }
61   if(fLowSDDValue)
62     {
63       delete[]fLowSDDValue;
64       fLowSDDValue=NULL;
65     }
66   if(fHighSDDValue)
67     { 
68       delete[]fHighSDDValue;
69       fHighSDDValue=NULL;
70     }
71   if(fCalibration)
72     {
73       delete fCalibration;
74       fCalibration=NULL;
75     }
76 } // dtor
77
78 //__________________________________________________________________
79 Double_t AliITSQASDDChecker::Check(AliQAv1::ALITASK_t index, TObjArray * list, const AliDetectorRecoParam * /*recoparam*/) 
80 {  
81   AliInfo(Form("AliITSQASDDChecker called with offset: %d\n", fSubDetOffset) );
82
83   AliDebug(1,Form("AliITSQASDDChecker called with offset: %d\n", fSubDetOffset));
84
85   Double_t test = 0.;
86   TH1 *hdata=NULL;
87   Double_t entries=0.;
88   Double_t entries2[2];
89   for(Int_t i=0;i<2;i++)entries2[i]=0.;
90   switch(index)
91     {
92
93     case AliQAv1::kRAW:
94       AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
95       if(!fCalibration){
96         AliCDBEntry *calibSDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD");
97         Bool_t cacheStatus = AliCDBManager::Instance()->GetCacheFlag();
98         if(!calibSDD)
99           {
100             AliError("Calibration object retrieval failed! SDD will not be processed");
101             fCalibration = NULL;
102             test= fHighSDDValue[AliQAv1::kWARNING];
103           }
104         fCalibration = (TObjArray *)calibSDD->GetObject();
105         
106         if(!cacheStatus)calibSDD->SetObject(NULL);
107         calibSDD->SetOwner(kTRUE);
108         if(!cacheStatus)
109           {
110             delete calibSDD;
111           }
112       }
113       AliInfo("Calib SDD Created\n ");
114       
115       if (list->GetEntries() == 0.){ //check if the list is empty
116         //printf("test = %f \t value %f\n",test,fHighSDDValue[AliQAv1::kFATAL]);
117         test=test+fHighSDDValue[AliQAv1::kFATAL];
118         break;
119       }//end if getentries
120       else{
121         TIter next(list);
122         Int_t offset = 0;
123         for(offset =0;offset < fSubDetOffset; offset++){hdata = dynamic_cast<TH1*>(next());}//end for
124         Int_t emptymodules[2];
125         Int_t filledmodules[2];
126         Int_t emptyladders[2];
127         Int_t filledladders[2];
128         for(Int_t i=0;i<2;i++){
129           emptymodules[i]=0;
130           filledmodules[i]=0;
131           emptyladders[i]=0;
132           filledladders[i]=0;
133         }
134         TH1 *hmodule=NULL;
135         TH2 *hlayer[2];
136         for(Int_t i=0;i<2;i++)hlayer[i]=NULL;    
137         while( hdata = dynamic_cast<TH1* >(next()) ){
138           if (hdata){
139             TString hname=hdata->GetName();
140             if(hname.Contains("SDDchargeMap"))continue;
141             if(hname.Contains("SDDModPattern")){
142               hmodule=hdata;
143               entries= hdata->GetEntries();
144               if(entries==0){
145                 AliWarning(Form("===================>>>>>> No entries in  %s \n",hname.Data()));
146                 //printf("test = %f \t value %f\n",test,fHighSDDValue[AliQAv1::kFATAL]);
147                 test=test+fStepBitSDD[AliQAv1::kFATAL];
148               }//endif entries
149               else{
150                 int modmax=hdata->GetNbinsX();
151                 Int_t empty=0;
152                 Int_t filled=0;
153                 Double_t content=0;
154                 for(Int_t i=1;i<=modmax;i++){
155                   content=hdata->GetBinContent(i);
156                   if(content==0.){empty++;}
157                   else if(content!=0.){filled++;}
158                 }//end for
159                 AliInfo(Form(" %s : empty modules %i \t filled modules %i",hname.Data(), empty, filled));
160               }//end else pattern entries !=0         
161             }//end if modpattern
162             else if(hname.Contains("SDDphizL3")||hname.Contains("SDDphizL4")){
163               Int_t layer=0;
164               if(hname.Contains("3"))layer=0;
165               else  if(hname.Contains("4"))layer=1;
166               entries2[layer]=hdata->GetEntries();
167               if(entries2[layer]==0){
168                 AliWarning(Form("===================>>>>>> No entries in  %s \n",hname.Data()));
169                 //printf("test = %f \t value %f\n",test,fStepBitSDD[AliQAv1::kFATAL]);
170                 test=test+fStepBitSDD[AliQAv1::kFATAL];
171                 if(entries==0){ 
172                   //return test; 
173                   //break;
174                 }
175               }//end if getentries
176               else{
177                 Int_t layer=0;
178                 if(hname.Contains("3"))layer=0;
179                 else  if(hname.Contains("4"))layer=1;
180                 hlayer[layer]=dynamic_cast<TH2*>(hdata); 
181                 hlayer[layer]->RebinX(2);
182                 int modmay=hlayer[layer]->GetNbinsY();
183                 TH1D* hproj= hlayer[layer]->ProjectionY();
184                 Double_t ladcontent=0;
185                 for(Int_t i=1;i<=modmay;i++) {//loop on the ladders
186                   ladcontent=hproj->GetBinContent(i);
187                   if(ladcontent==0){emptyladders[layer]++;}
188                   else if(ladcontent!=0){filledladders[layer]++;} 
189                 }//end for
190                 AliInfo(Form(" %s : empty ladders %i \t filled ladders %i\n",hname.Data(), emptyladders[layer], filledladders[layer]));//end else layer 3
191                 delete hproj;
192                 hproj=NULL;     
193               }//end else entries !=0         
194             }//end if layer 3
195           }//end if hdata       
196         }//end while
197         if(entries==0.&&entries2[0]==0.&&entries2[1]==0.) break;
198         else{
199           if(hmodule||(hlayer[0]&&hlayer[1])){
200             Int_t excluded=0;
201             Int_t active=0;
202             Int_t exactive=0;//excluded but taking data
203             //AliITSCalibrationSDD *cal;
204             for(Int_t imod=0;imod<fgknSDDmodules;imod++){
205               Int_t lay=0;
206               Int_t lad=0;
207               Int_t det=0;
208               Int_t module=0;
209               module=imod+fgkmodoffset;
210               AliITSCalibrationSDD * cal=(AliITSCalibrationSDD*)fCalibration->At(imod);
211               if(cal==0) { delete cal; continue;}
212               AliITSgeomTGeo::GetModuleId(module,lay,lad,det);
213               if (cal->IsBad()){
214                 excluded++;
215                 Double_t content=0.;
216                 Double_t contentlayer[2];
217                 for(Int_t i=0;i<2;i++)contentlayer[i]=0.;
218                 if(hmodule)content=hmodule->GetBinContent(imod+1);//if expert bit is active the histogram has been created 
219                 contentlayer[lay-3]=hlayer[lay-3]->GetBinContent(det,lad);
220                 if(content!=0.||contentlayer[lay-3]!=0.)
221                   {
222                     filledmodules[lay-3]++;
223                     AliWarning(Form("The module %d (layer %i, ladder %i det %i ) excluded from the acquisition, took data \n ",module,lay,lad,det));
224                     exactive++;
225                   }
226                 else if(content==0.&&contentlayer[lay-3]==0.)emptymodules[lay-3]++;
227                 //AliInfo(Form("The module %d (layer %i, ladder %i det %i ) is bad, content %f content layer %f  filled modules position %d ",module,lay,lad,det,contentlayer[lay-3],content,lay-3) );
228               }//end if bad
229               else
230                 {
231                   Double_t contentgood=0.;
232                   active++;
233                   //printf("lay: %i\t det %i \t lad %i \n",lay,det,lad );
234                   contentgood=hlayer[lay-3]->GetBinContent(det,lad);
235                   if(contentgood==0.){emptymodules[lay-3]++;}
236                   else if(contentgood!=0.){filledmodules[lay-3]++;}
237                 }
238               
239               //delete cal;
240               //cal=NULL;
241             }//end for
242             for(Int_t i=0;i<2;i++){AliInfo(Form(" %s :Layer %i \tempty modules %i \t filled modules %i\n",hlayer[i]->GetName(), i+3,emptymodules[i], filledmodules[i]));}//end else layers
243             if(exactive==0){
244               AliInfo(Form("All the active modules (%i) are in acquisition. The number of excluded modules are %i \n",active,excluded));
245               test=fHighSDDValue[AliQAv1::kINFO];}
246             if(exactive!=0){
247               AliWarning(Form("%i modules excluded from the acquisition took data. Active modules%i \n ",exactive,active));
248               test=fHighSDDValue[AliQAv1::kWARNING];
249             }
250             if(excluded==exactive){
251               AliWarning(Form("All the modules exluded from the acquisition (%d) took data!  Active modules %i\n",excluded,active));
252               test=fHighSDDValue[AliQAv1::kWARNING];
253             }
254             if(active==0){
255               AliWarning(Form("No modules took data: excluded %i \t exactive %i \n", excluded, exactive)); 
256               test=fHighSDDValue[AliQAv1::kFATAL];
257             }
258           } 
259         }
260       }//end getentries !=0
261       //delete calSDD;
262       
263       
264       
265       //delete calibSDD;
266       //delete calSDD;
267    
268       break;
269     case AliQAv1::kNULLTASK:
270       AliInfo(Form("No Check on %s\n",AliQAv1::GetAliTaskName(index))); 
271       test=1.;
272       break;
273     case AliQAv1::kSIM:
274       AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index))); 
275       test=1.;
276       break;
277     case AliQAv1::kREC:
278       AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index))); 
279       test=1.;
280       break;
281     case AliQAv1::kANA:
282       AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
283       test=1.; 
284       break;
285     case AliQAv1::kESD:
286       AliInfo(Form("Check on %s\n",AliQAv1::GetAliTaskName(index)));
287       test=1.; 
288       break;
289     case AliQAv1::kNTASK:
290       AliInfo(Form("No Check on %s\n",AliQAv1::GetAliTaskName(index))); 
291       test=1.;
292       break;
293       
294     }//end switch
295   delete hdata;
296   return test;  
297 }
298  
299 //__________________________________________________________________
300 void AliITSQASDDChecker::SetTaskOffset(Int_t taskoffset)
301 {
302   fSubDetOffset = taskoffset;
303 }
304
305
306 //__________________________________________________________________
307 void AliITSQASDDChecker::SetStepBit(Double_t *steprange)
308 {
309
310   fStepBitSDD = new Double_t[AliQAv1::kNBIT];
311   for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
312     {
313       fStepBitSDD[bit]=steprange[bit];
314     }
315 }
316
317 //__________________________________________________________________
318 void  AliITSQASDDChecker::SetSDDLimits(Float_t *lowvalue, Float_t * highvalue)
319 {
320
321   fLowSDDValue = new Float_t[AliQAv1::kNBIT];
322   fHighSDDValue= new Float_t[AliQAv1::kNBIT];
323
324   for(Int_t bit=0;bit<AliQAv1::kNBIT;bit++)
325     {
326       fLowSDDValue[bit]=lowvalue[bit];
327       fHighSDDValue[bit]= highvalue[bit];
328     }
329
330 }
331
332