2b11813dff30fd68676eb505c6a2ff40632cfcd0
[u/mrichter/AliRoot.git] / ITS / AliITSQAChecker.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 //  W.Ferrarese  P.Cerello  Mag 2008
22 //  INFN Torino
23
24 // --- ROOT system ---
25 #include "TH1.h"
26 #include <Riostream.h>
27
28 // --- AliRoot header files ---
29 #include "AliITSQAChecker.h"
30 #include "AliITSQASPDChecker.h"
31 #include "AliITSQASDDChecker.h"
32 #include "AliITSQASSDChecker.h"
33
34 ClassImp(AliITSQAChecker)
35
36 //____________________________________________________________________________
37 AliITSQAChecker::AliITSQAChecker(Bool_t kMode, Short_t subDet, Short_t ldc) :
38 AliQACheckerBase("ITS","SDD Quality Assurance Checker"),
39 fkOnline(0),
40 fDet(0),  
41 fLDC(0),
42 fSPDOffset(0), 
43 fSDDOffset(0), 
44 fSSDOffset(0),
45 fSPDChecker(0),  // SPD Checker
46 fSDDChecker(0),  // SDD Checker
47 fSSDChecker(0)  // SSD Checker
48 {
49   // Standard constructor
50   fkOnline = kMode; fDet = subDet; fLDC = ldc;
51   if(fDet == 0 || fDet == 1) {
52     AliDebug(1,"AliITSQAChecker::Create SPD Checker\n");
53   }
54   if(fDet == 0 || fDet == 2) {
55     AliDebug(1,"AliITSQAChecker::Create SDD Checker\n");
56   }
57   if(fDet == 0 || fDet == 3) {
58     AliDebug(1,"AliITSQAChecker::Create SSD Checker\n");
59   }
60
61 }
62
63 //____________________________________________________________________________
64 AliITSQAChecker::AliITSQAChecker(const AliITSQAChecker& qac):
65 AliQACheckerBase(qac.GetName(), qac.GetTitle()), 
66 fkOnline(qac.fkOnline), 
67 fDet(qac.fDet), 
68 fLDC(qac.fLDC), 
69 fSPDOffset(qac.fSPDOffset), 
70 fSDDOffset(qac.fSDDOffset), 
71 fSSDOffset(qac.fSSDOffset), 
72 fSPDChecker(0), 
73 fSDDChecker(0), 
74 fSSDChecker(0) {
75   // copy constructor
76   AliError("Copy should not be used with this class\n");
77 }
78 //____________________________________________________________________________
79 AliITSQAChecker& AliITSQAChecker::operator=(const AliITSQAChecker& qac){
80   // assignment operator
81   this->~AliITSQAChecker();
82   new(this)AliITSQAChecker(qac);
83   return *this;
84 }
85
86 //____________________________________________________________________________
87 Double_t * AliITSQAChecker::Check(AliQA::ALITASK_t /*index*/)
88 {
89   Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ; 
90   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
91     rv[specie] = 0.5 ; 
92   return rv ;  
93 }
94
95 //____________________________________________________________________________
96 Double_t * AliITSQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list)
97 {
98   
99   // Super-basic check on the QA histograms on the input list:
100   // look whether they are empty!
101   if(index == AliQA::kESD){
102     Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ; 
103     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
104       rv[specie] = 0.0 ; 
105       if ( !AliQA::Instance()->IsEventSpecieSet(specie) ) 
106         continue ; 
107       AliDebug(1,"Checker for ESD");
108       Int_t tested = 0;
109       Int_t empty = 0;
110       // The following flags are set to kTRUE if the corresponding
111       // QA histograms exceed a given quality threshold
112       Bool_t cluMapSA = kFALSE;
113       Bool_t cluMapMI = kFALSE;
114       Bool_t cluMI = kFALSE;
115       Bool_t cluSA = kFALSE;
116       Bool_t verSPDZ = kFALSE;
117       if (list[specie]->GetEntries() == 0) {
118         rv[specie] = 0.; // nothing to check
119       }
120       else {
121         TIter next1(list[specie]);
122         TH1 * hdata;
123         Int_t nskipped=0;
124         Bool_t skipped[6]={kFALSE,kFALSE,kFALSE,kFALSE,kFALSE,kFALSE};
125         // look for layers that we wanted to skip
126         while ( (hdata = dynamic_cast<TH1 *>(next1())) ) {
127           if(!hdata) continue;
128           TString hname = hdata->GetName();
129           if(!hname.Contains("hESDSkippedLayers")) continue;
130           for(Int_t k=1; k<7; k++) {
131             if(hdata->GetBinContent(k)>0) { 
132               nskipped++; 
133               skipped[k-1]=kTRUE; 
134             } 
135           } 
136         }
137         TIter next(list[specie]);
138         while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
139           if(hdata){
140             TString hname = hdata->GetName();
141             Double_t entries = hdata->GetEntries();
142             ++tested;
143             if(!(entries>0.))++empty;
144             AliDebug(1,Form("ESD hist name %s - entries %12.1g",hname.Data(),entries));
145             if(hname.Contains("hESDClusterMapSA") && entries>0.){
146               cluMapSA = kTRUE;
147               AliDebug(1,Form("Processing histogram %s",hname.Data()));
148               // Check if there are layers with anomalously low 
149               // contributing points to SA reconstructed tracks
150               for(Int_t k=1;k<7;k++){
151                 // check if the layer was skipped
152                 if(skipped[k-1]) continue;
153                 if(hdata->GetBinContent(k)<0.5*(entries/6.)){
154                   cluMapSA = kFALSE;
155                   AliInfo(Form("SA tracks have few points on layer %d - look at histogram hESDClustersSA",k));
156                 }
157               }  
158             }
159
160             else if(hname.Contains("hESDClusterMapMI") && entries>0.){
161               // Check if there are layers with anomalously low 
162               // contributing points to MI reconstructed tracks
163               AliDebug(1,Form("Processing histogram %s",hname.Data()));
164               cluMapMI = kTRUE;
165               for(Int_t k=1;k<7;k++){
166                 // check if the layer was skipped
167                 if(skipped[k-1]) continue;
168                 if(hdata->GetBinContent(k)<0.5*(entries/6.)){
169                   cluMapMI = kFALSE;
170                   AliInfo(Form("MI tracks have few points on layer %d - look at histogram hESDClustersMI",k));
171                 }
172               }  
173             }
174
175             else if(hname.Contains("hESDClustersMI") && entries>0.){
176               // Check if 6 clusters MI tracks are the majority
177               AliDebug(1,Form("Processing histogram %s",hname.Data()));
178               cluMI = kTRUE;
179               Double_t maxlaytracks = hdata->GetBinContent(7-nskipped);
180               for(Int_t k=2; k<7-nskipped; k++){
181                 if(hdata->GetBinContent(k)>maxlaytracks){
182                   cluMI = kFALSE;
183                   AliInfo(Form("MI Tracks with %d clusters are more than tracks with %d clusters. Look at histogram hESDClustersMI",k-1,6-nskipped));
184                 }
185               }
186             }
187
188             else if(hname.Contains("hESDClustersSA") && entries>0.){
189               // Check if 6 clusters SA tracks are the majority
190               AliDebug(1,Form("Processing histogram %s",hname.Data()));
191               cluSA = kTRUE;
192               Double_t maxlaytracks = hdata->GetBinContent(7-nskipped);
193               for(Int_t k=2; k<7-nskipped; k++){
194                 if(hdata->GetBinContent(k)>maxlaytracks){
195                   cluSA = kFALSE;
196                   AliInfo(Form("SA Tracks with %d clusters are more than tracks with %d clusters. Look at histogram hESDClustersSA",k-1,6-nskipped));
197                 }
198               }
199             }
200
201             else if(hname.Contains("hSPDVertexZ") && entries>0.){
202               // Check if average Z vertex coordinate is -5 < z < 5 cm
203               AliDebug(1,Form("Processing histogram %s",hname.Data()));
204               verSPDZ = kTRUE;
205               if(hdata->GetMean()<-5. && hdata->GetMean()>5.){
206                 verSPDZ = kFALSE;
207                 AliInfo(Form("Average z vertex coordinate is at z= %10.4g cm",hdata->GetMean()));
208               }
209             }
210           }
211
212           else{
213             AliError("ESD Checker - invalid data type");
214           }
215           
216           rv[specie] = 0.;
217           if(tested>0){
218             if(tested == empty){
219               rv[specie] = 0.1;
220               AliWarning("All ESD histograms are empty");
221             }
222             else {
223               rv[specie] = 0.1+0.4*(static_cast<Double_t>(tested-empty)/static_cast<Double_t>(tested));
224               if(cluMapSA)rv[specie]+=0.1;
225               if(cluMapMI)rv[specie]+=0.1;
226               if(cluMI)rv[specie]+=0.1;
227               if(cluSA)rv[specie]+=0.1;
228               if(verSPDZ)rv[specie]+=0.1;
229             }
230           }
231         }
232       }  
233       AliInfo(Form("ESD - Tested %d histograms, Return value %f \n",tested,rv[specie]));
234     }
235     return rv ; 
236   }  // end of ESD QA
237   
238   Double_t * retval = new Double_t[AliRecoParam::kNSpecies] ; 
239   //____________________________________________________________________________
240
241   Double_t spdCheck, sddCheck, ssdCheck;
242   //pixel
243   if(fDet == 0 || fDet == 1) {
244     AliDebug(1,"AliITSQAChecker::Create SPD Checker\n");
245     if(!fSPDChecker) {
246       fSPDChecker = new AliITSQASPDChecker();
247     }
248     fSPDChecker->SetTaskOffset(fSPDOffset);
249     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
250       retval[specie] = 1.0 ; 
251       if ( AliQA::Instance()->IsEventSpecieSet(specie) ) {
252         spdCheck = fSPDChecker->Check(index, list[specie]);
253         if(spdCheck<retval[specie])retval[specie] = spdCheck;
254       }
255     }
256   }
257   //drift
258   if(fDet == 0 || fDet == 2) {
259     AliDebug(1,"AliITSQAChecker::Create SDD Checker\n");
260     if(!fSDDChecker) {
261       fSDDChecker = new AliITSQASDDChecker();
262     }
263     fSDDChecker->SetTaskOffset(fSDDOffset);
264     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
265       retval[specie] = 1.0 ; 
266       if ( AliQA::Instance()->IsEventSpecieSet(specie) ) {
267         sddCheck = fSDDChecker->Check(index, list[specie]);
268         if(sddCheck<retval[specie])retval[specie] = sddCheck;
269       }
270     }
271   }
272   //strip
273   if(fDet == 0 || fDet == 3) {
274     AliDebug(1,"AliITSQAChecker::Create SSD Checker\n");
275     if(!fSSDChecker) {
276       fSSDChecker = new AliITSQASSDChecker();
277       AliInfo(Form("Number of monitored objects SSD: %d", list[AliRecoParam::kDefault]->GetEntries()));
278     }
279     fSSDChecker->SetTaskOffset(fSSDOffset);
280     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
281       retval[specie] = 1.0 ; 
282       if ( AliQA::Instance()->IsEventSpecieSet(specie) ) {
283         ssdCheck = fSSDChecker->Check(index, list[specie]);
284         if(ssdCheck<retval[specie])retval[specie] = ssdCheck;  
285       }
286     }
287   }
288   // here merging part for common ITS QA result
289   // 
290
291   return retval;  
292 }
293
294
295 //____________________________________________________________________________
296 void AliITSQAChecker::SetTaskOffset(Int_t SPDOffset, Int_t SDDOffset, Int_t SSDOffset)
297 {
298   //Setting the 3 offsets for each task called
299   fSPDOffset = SPDOffset;
300   fSDDOffset = SDDOffset;
301   fSSDOffset = SSDOffset;
302 }
303
304  //____________________________________________________________________________
305  void AliITSQAChecker::SetDetTaskOffset(Int_t subdet,Int_t offset)
306  {
307    switch(subdet){
308    case 1:
309      SetSPDTaskOffset(offset);
310      break;
311    case 2:
312      SetSDDTaskOffset(offset);
313      break;
314    case 3:
315      SetSSDTaskOffset(offset);
316      break;
317    default:
318      AliWarning("No specific (SPD,SDD or SSD) subdetector correspond to to this number!!! all offsets set to zero for all the detectors\n");
319      SetTaskOffset(0, 0, 0);
320      break;
321    }
322  }