Non-implemented private copy constructor and assignment operator
[u/mrichter/AliRoot.git] / FMD / AliFMDQAChecker.cxx
1 /**************************************************************************
2  * Copyright(c) 2004, 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 //
17 // Yves?
18 // What 
19 // is 
20 // this 
21 // class 
22 // supposed 
23 // to
24 // do?
25 //__________________________________________________________________
26 //
27 // --- ROOT system ---
28 #include <TClass.h>
29 #include <TH1F.h> 
30 #include <TH2.h> 
31 #include <TH1I.h> 
32 #include <TIterator.h> 
33 #include <TKey.h> 
34 #include <TFile.h> 
35 #include <iostream>
36 #include <TCanvas.h>
37 #include <TPaveText.h>
38 #include <TStyle.h>
39 #include <TLatex.h>
40
41 // --- AliRoot header files ---
42 #include "AliLog.h"
43 #include "AliQAv1.h"
44 #include "AliQAChecker.h"
45 #include "AliFMDQAChecker.h"
46 #include "AliRecoParam.h"
47
48 ClassImp(AliFMDQAChecker)
49 #if 0
50 ; // This is for Emacs! - do not delete
51 #endif
52
53 //__________________________________________________________________
54 Double_t 
55 AliFMDQAChecker::CheckOne(AliQAv1::ALITASK_t          what,
56                           AliRecoParam::EventSpecie_t specie, 
57                           TH1*                        hist) const
58 {
59   if(what == AliQAv1::kESD) return CheckESD(specie, hist);
60   if(what == AliQAv1::kRAW) return CheckRaw(specie, hist);
61   if(what == AliQAv1::kSIM) return CheckSim(specie, hist);
62   if(what == AliQAv1::kREC) return CheckRec(specie, hist);
63   return 0;
64 }
65 //__________________________________________________________________
66 Double_t 
67 AliFMDQAChecker::CheckESD(AliRecoParam::EventSpecie_t /* specie*/, 
68                           TH1*                        hist) const
69 {
70   return (hist->GetMean() > 0 ? 1 : 0);
71 }
72 //__________________________________________________________________
73 Double_t 
74 AliFMDQAChecker::CheckRaw(AliRecoParam::EventSpecie_t /* specie*/, 
75                           TH1*                        hist) const
76 {
77   return (hist->GetMean() > 0 ? 1 : 0);
78 }
79 //__________________________________________________________________
80 Double_t 
81 AliFMDQAChecker::CheckSim(AliRecoParam::EventSpecie_t /* specie*/, 
82                           TH1*                        hist) const
83 {
84   return (hist->GetMean() > 0 ? 1 : 0);
85 }
86 //__________________________________________________________________
87 Double_t 
88 AliFMDQAChecker::CheckRec(AliRecoParam::EventSpecie_t /* specie*/, 
89                           TH1*                        hist) const
90 {
91   return (hist->GetMean() > 0 ? 1 : 0);
92 }
93
94 //__________________________________________________________________
95 void AliFMDQAChecker::Check(Double_t*                   rv, 
96                             AliQAv1::ALITASK_t          what, 
97                             TObjArray**                 list, 
98                             const AliDetectorRecoParam* /*t*/) 
99 {
100   // 
101   // Member function called to do the actual checking
102   //
103   // Parameters: 
104   //    rv   Array of return values. 
105   //    what What to check 
106   //    list Array of arrays of histograms.  There's one arrat for
107   //         each 'specie'
108   //    t    Reconstruction parameters - not used. 
109   //
110   
111   // Double_t* rv = new Double_t[AliRecoParam::kNSpecies] ; 
112   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
113     // Int_t count   = 0;
114     rv[specie]    = 0.; 
115
116     if (!AliQAv1::Instance()->IsEventSpecieSet(specie) ) 
117       continue ;
118     
119     if(!list[specie]) continue;
120     
121     TH1* hist  = 0;
122     Int_t nHist = list[specie]->GetEntriesFast();
123     for(Int_t i= 0; i< nHist; i++) {
124       
125       if (!(hist = static_cast<TH1*>(list[specie]->At(i)))) continue;
126       
127       rv[specie] += CheckOne(what, AliRecoParam::ConvertIndex(specie), hist);
128     } // for (int i ...)
129     // if (count != 0) rv[specie] /= count;
130   }
131   // return rv;
132 }
133
134 namespace {
135   Int_t CheckForLog(TAxis*       axis,
136                     TVirtualPad* pad, 
137                     Int_t        xyz)
138   {
139     Int_t ret = 0;
140     TString t(axis->GetTitle());
141     if (!t.Contains("[log]", TString::kIgnoreCase)) return 0;
142     t.ReplaceAll("[log]", "");
143     switch (xyz) { 
144     case 1: pad->SetLogx(); ret |= 0x1; break;
145     case 2: pad->SetLogy(); ret |= 0x2; break;
146     case 3: pad->SetLogz(); ret |= 0x4; break;
147     }
148     axis->SetTitle(t);
149     return ret;
150   }
151   void RestoreLog(TAxis* axis, Bool_t log) 
152   {
153     if (!log) return;
154     TString t(axis->GetTitle());
155     t.Append("[log]");
156     axis->SetTitle(t);
157   }
158 }
159
160 namespace {
161   void FindMinMax(TH1* h, Double_t& min, Double_t& max)
162   {
163     Double_t tmin = 1e9;
164     Double_t tmax = 0;
165     for (Int_t i = 1; i <= h->GetNbinsX(); i++) { 
166       Double_t c = h->GetBinContent(i);
167       if (c < 1e-8) continue;
168       tmin = TMath::Min(tmin, c);
169       tmax = TMath::Max(tmax, c);
170     }
171     min = tmin;
172     max = tmax;
173   }
174 }
175 //____________________________________________________________________________ 
176 void 
177 AliFMDQAChecker::MakeImage(TObjArray** list, 
178                            AliQAv1::TASKINDEX_t task, 
179                            AliQAv1::MODE_t mode) 
180 {
181   // makes the QA image for sim and rec
182   // 
183   // Parameters: 
184   //    task What to check 
185   //    list Array of arrays of histograms.  There's one array for
186   //         each 'specie'
187   //    t    Reconstruction parameters - not used. 
188   // 
189   Int_t    nImages = 0 ;
190   Double_t max     = 0;
191   Double_t min     = 10000;
192
193   // Loop over all species 
194   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
195     AliRecoParam::EventSpecie_t spe = AliRecoParam::ConvertIndex(specie);
196     if (!AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))
197         ->IsEventSpecieSet(spe)) 
198       continue;
199                                                                         
200     // If nothing is defined for this specie, go on. 
201     if(!list[specie] || list[specie]->GetEntriesFast() == 0) continue;
202
203     // Loop over the histograms and figure out how many histograms we
204     // have and the min/max 
205     TH1* hist  = 0;
206     Int_t nHist = list[specie]->GetEntriesFast();
207     for(Int_t i= 0; i< nHist; i++) {
208       hist = static_cast<TH1F*>(list[specie]->At(i));
209       if (hist && hist->TestBit(AliQAv1::GetImageBit())) {
210         nImages++; 
211         TString name(hist->GetName());
212         if (name.Contains("readouterrors", TString::kIgnoreCase)) continue;
213
214         // Double_t hMax = hist->GetMaximum(); 
215         // hist->GetBinContent(hist->GetMaximumBin());
216         // Double_t hMin = hist->GetMinimum();
217         // hist->GetBinContent(hist->GetMinimumBin());
218         Double_t hMax, hMin;
219         FindMinMax(hist, hMin, hMax);
220         max = TMath::Max(max, hMax);
221         min = TMath::Min(min, hMin);
222         AliInfoF("Min/max of %40s: %f/%f, global -> %f/%f", 
223                  hist->GetName(), hMin, hMax, min, max);
224       }
225     }
226     break ; 
227   }
228   AliInfoF("Global min/max=%f/%f", min, max);
229   min = TMath::Max(1e-1, min);
230   max = TMath::Max(1e5,  max);
231
232   // IF no images, go on. 
233   if (nImages == 0) {
234     AliDebug(AliQAv1::GetQADebugLevel(), 
235              Form("No histogram will be plotted for %s %s\n", GetName(), 
236                   AliQAv1::GetTaskName(task).Data()));
237     return;
238   }
239
240   AliDebug(AliQAv1::GetQADebugLevel(), 
241            Form("%d histograms will be plotted for %s %s\n", 
242                 nImages, GetName(), AliQAv1::GetTaskName(task).Data()));  
243   gStyle->SetOptStat(0);
244   
245   // Again loop over species and draw a canvas 
246   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
247     if (!AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))
248         ->IsEventSpecieSet(specie)) continue;
249
250     // if Nothing here, go on
251     if(!list[specie] || list[specie]->GetEntries() <= 0 || 
252        nImages <= 0) continue;
253
254    // Form the title 
255     const Char_t * title = Form("QA_%s_%s_%s", GetName(), 
256                                 AliQAv1::GetTaskName(task).Data(), 
257                                 AliRecoParam::GetEventSpecieName(specie)); 
258     if (!fImage[specie]) fImage[specie] = new TCanvas(title, title) ;
259     fImage[specie]->Clear() ; 
260     fImage[specie]->SetTitle(title) ; 
261     fImage[specie]->cd() ; 
262
263     // Put something in the canvas - even if empty 
264     TPaveText someText(0.015, 0.015, 0.98, 0.98) ;
265     someText.AddText(title) ;
266     someText.SetFillColor(0);
267     someText.SetFillStyle(0);
268     someText.SetBorderSize(0);
269     someText.SetTextColor(kRed+1);
270     someText.Draw() ; 
271     TString outName(Form("%s%s%d.%s", AliQAv1::GetImageFileName(), 
272                          AliQAv1::GetModeName(mode), 
273                          AliQAChecker::Instance()->GetRunNumber(), 
274                          AliQAv1::GetImageFileFormat()));
275     fImage[specie]->Print(outName, "ps") ; 
276
277
278     // Now set some parameters on the canvas 
279     fImage[specie]->Clear(); 
280     fImage[specie]->SetTopMargin(0.10);
281     fImage[specie]->SetBottomMargin(0.15);
282     fImage[specie]->SetLeftMargin(0.15);
283     fImage[specie]->SetRightMargin(0.05);
284     
285     // Put title on top 
286     const char* topT = Form("Mode: %s, Task: %s, Specie: %s, Run: %d",
287                             AliQAv1::GetModeName(mode), 
288                             AliQAv1::GetTaskName(task).Data(), 
289                             AliRecoParam::GetEventSpecieName(specie),
290                             AliQAChecker::Instance()->GetRunNumber());
291     TLatex* topText = new TLatex(.5, .99, topT);
292     topText->SetTextAlign(23);
293     topText->SetTextSize(.038);
294     topText->SetTextFont(42);
295     topText->SetTextColor(kBlue+3);
296     topText->SetNDC();
297     topText->Draw();
298                                  
299     // Divide canvas 
300     Int_t nx = int(nImages + .5) / 2;
301     Int_t ny = 2;
302     // if (fDoScale) 
303     fImage[specie]->Divide(nx, ny, 0, 0);
304     // else fImage[specie]->Divide(nx, ny);
305     
306     
307     // Loop over histograms 
308     TH1*  hist  = 0;
309     Int_t nHist = list[specie]->GetEntriesFast();
310     Int_t j     = 0;
311     for (Int_t i = 0; i < nHist; i++) { 
312       hist = static_cast<TH1*>(list[specie]->At(i));
313       if (!hist || !hist->TestBit(AliQAv1::GetImageBit())) continue;
314
315       // Go to sub-pad 
316       TVirtualPad* pad = fImage[specie]->cd(++j);
317       pad->SetRightMargin(0.01);
318       if (!fDoScale) { 
319         pad->SetLeftMargin(0.10);
320         pad->SetBottomMargin(0.10);
321       }
322
323       // Check for log scale 
324       Int_t logOpts = 0;
325       logOpts |= CheckForLog(hist->GetXaxis(), pad, 1);
326       logOpts |= CheckForLog(hist->GetYaxis(), pad, 2);
327       logOpts |= CheckForLog(hist->GetZaxis(), pad, 3);
328
329       // Figure out special cases 
330       TString opt;
331       TString name(hist->GetName());
332       if (name.Contains("readouterrors", TString::kIgnoreCase)) {
333         pad->SetRightMargin(0.15);
334         pad->SetBottomMargin(0.10);
335         // pad->SetTopMargin(0.02);
336         opt="COLZ";
337       }
338       else {
339         pad->SetGridx();
340         pad->SetGridy();
341         if (fDoScale) { 
342           hist->SetMinimum(min);
343           hist->SetMaximum(max);
344         }
345         else { 
346           hist->SetMinimum();
347           hist->SetMaximum();
348         }
349       }
350       // Draw (As a copy)
351       hist->DrawCopy(opt);
352
353       // Special cases 
354       if (name.Contains("readouterrors", TString::kIgnoreCase)) {
355         for (Int_t kk = 1; kk <= 3; kk++) {
356           TH1* proj = static_cast<TH2*>(hist)->ProjectionY("",kk,kk);
357         Double_t m = proj->GetMean(); 
358         TLatex* l = new TLatex(kk, 30, Form("Mean: %f", m));
359         l->SetTextAngle(90);
360         l->SetTextColor(m > 10 ? kRed+1 : m > .7 ? kOrange+2 :kGreen+2);
361         l->Draw();
362       }
363       }
364       else {
365         gStyle->SetOptTitle(0);
366         TPad* insert = new TPad("insert", "Zoom", 
367                                 .4,.4, .99, .95, 0, 0, 0);
368         insert->SetTopMargin(0.01);
369         insert->SetRightMargin(0.01);
370         insert->SetFillColor(0);
371         insert->SetBorderSize(1);
372         insert->SetBorderMode(0);
373         insert->Draw();
374         insert->cd();
375         if (logOpts & 0x1) insert->SetLogx();
376         if (logOpts & 0x2) insert->SetLogy();
377         if (logOpts & 0x4) insert->SetLogz();
378         hist->GetXaxis()->SetRange(1, hist->GetNbinsX()/8);
379         TH1* copy = hist->DrawCopy(opt);
380         copy->GetXaxis()->SetNdivisions(408, false);
381         // Restore full range 
382         hist->GetXaxis()->SetRange(0, 0);
383         gStyle->SetOptTitle(1);
384       }
385       pad->cd();
386       // Possibly restore the log options 
387       RestoreLog(hist->GetXaxis(), logOpts & 0x1);
388       RestoreLog(hist->GetYaxis(), logOpts & 0x2);
389       RestoreLog(hist->GetZaxis(), logOpts & 0x4);
390     }
391     // Print to a post-script file 
392     fImage[specie]->Print(outName, "ps");
393   }
394 }
395
396 //__________________________________________________________________
397 //
398 // EOF
399 //