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 //