EMCAL/AliEMCALQAChecker.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, 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   Checks the quality assurance.
  18   By comparing with reference data
  19
  20   Based on PHOS code written by
  21   Y. Schutz CERN July 2007
  22
  23  For the moment we only implement the checking of raw data QA.
  24  The checked for ESD and RecPoints will be implemented later.
  25
  26
  27  */
  28
  29
  30 // --- ROOT system ---
  31 #include <TClass.h>
  32 #include <TH1.h>
  33 #include <TF1.h>
  34 #include <TH1I.h>
  35 #include <TH2F.h>
  36 #include <TIterator.h>
  37 #include <TKey.h>
  38 #include <TFile.h>
  39 #include <TLine.h>
  40 #include <TText.h>
  41 #include <TPaveText.h>
  42 #include <TMath.h>
  43
  44 // --- Standard library ---
  45
  46 // --- AliRoot header files ---
  47 #include "AliLog.h"
  48 #include "AliQAv1.h"
  49 #include "AliQAChecker.h"
  50 #include "AliEMCALQAChecker.h"
  51
  52 ClassImp(AliEMCALQAChecker)
  53
  54 //__________________________________________________________________
  55 AliEMCALQAChecker::AliEMCALQAChecker() :
  56 AliQACheckerBase("EMCAL","EMCAL Quality Assurance Data Maker"),
  57 fTextSM(new TText*[fgknSM]),
  58 fLineCol(new TLine(47.5,-0.5,47.5,119.5)),
  59 fText(new TPaveText(0.2,0.7,0.8,0.9,"NDC"))
  60 {
  61   // ctor
  62   fLineCol->SetLineColor(1);
  63   fLineCol->SetLineWidth(2);
  64
  65   fTextSM[0]= new TText(20, 12, "SM A0");
  66   fTextSM[1]= new TText(20, 36, "SM A1");
  67   fTextSM[2]= new TText(20, 60, "SM A2");
  68   fTextSM[3]= new TText(20, 84, "SM A3");
  69   fTextSM[4]= new TText(20, 108,"SM A4");
  70   fTextSM[5]= new TText(20, 132,"SM A5");
  71
  72   fTextSM[6]= new TText(64, 12, "SM C0");
  73   fTextSM[7]= new TText(64, 36, "SM C1");
  74   fTextSM[8]= new TText(64, 60, "SM C2");
  75   fTextSM[9]= new TText(64, 84, "SM C3");
  76   fTextSM[10]= new TText(64, 108,"SM C4");
  77   fTextSM[11]= new TText(64, 132,"SM C5");
  78
  79         for(int i = 0; i < 5; i++) {
  80                 fLineRow[i] = new TLine(-0.5,23.5+(24*i),95.5,23.5+(24*i));
  81                 fLineRow[i]->SetLineColor(1);
  82                 fLineRow[i]->SetLineWidth(2);
  83         }
  84
  85         for(int i = 0; i < 3; i++) {
  86                 fTextL1[i] = new TPaveText(0.2,0.7,0.8,0.9,"NDC");
  87         }
  88
  89
  90 }
  91
  92 //__________________________________________________________________
  93 AliEMCALQAChecker::~AliEMCALQAChecker()
  94 {
  95         /// dtor
  96   delete [] fTextSM ;
  97   delete fLineCol ;
  98   for (Int_t i=0; i<5; ++i) delete fLineRow[i] ;
  99   delete fText  ;
 100 }
 101
 102 //______________________________________________________________________________
 103 void AliEMCALQAChecker::Check(Double_t * test, AliQAv1::ALITASK_t index, TObjArray ** list, const AliDetectorRecoParam * /*recoParam*/)
 104 {
 105         /// Check objects in list
 106
 107         if ( index == AliQAv1::kRAW )
 108         {
 109     CheckRaws(test, list);
 110                 printf ("checkers for task %d \n", index) ;
 111         }
 112
 113         if ( index == AliQAv1::kREC)
 114         {
 115     CheckRecPoints(test, list);
 116         }
 117
 118         if ( index == AliQAv1::kESD )
 119         {
 120     CheckESD(test, list);
 121         }
 122         AliWarning(Form("Checker for task %d not implement for the moment",index));
 123 }
 124
 125 //______________________________________________________________________________
 126 TH1*
 127 AliEMCALQAChecker::GetHisto(TObjArray* list, const char* hname, Int_t specie) const
 128 {
 129         /// Get a given histo from the list
 130         TH1* h = static_cast<TH1*>(list->FindObject(Form("%s_%s",AliRecoParam::GetEventSpecieName(specie),hname)));
 131         if (!h)
 132         {
 133                 AliError(Form("Did not find expected histo %s",hname));
 134         }
 135         return h;
 136 }
 137
 138 //______________________________________________________________________________
 139 Double_t
 140 AliEMCALQAChecker::MarkHisto(TH1& histo, Double_t value) const
 141 {
 142         /// Mark histo as originator of some QA error/warning
 143
 144         if ( value != 1.0 )
 145         {
 146                 histo.SetBit(AliQAv1::GetQABit());
 147         }
 148
 149         return value;
 150 }
 151
 152
 153 //______________________________________________________________________________
 154 void AliEMCALQAChecker::CheckRaws(Double_t * test, TObjArray ** list)
 155 {
 156   //  Check RAW QA histograms
 157   //  -- Yaxian Mao, CCNU/CERN/LPSC
 158   //adding new checking method: 25/04/2010, Yaxian Mao
 159   //Comparing the amplitude from current run to the reference run, if the ratio in the range [0.8, .12], count as a good tower.
 160   //If more than 90% towers are good, EMCAL works fine, otherwise experts should be contacted.
 161
 162   Int_t nTowersPerSM = 24*48; // number of towers in a SuperModule; 24x48
 163   Double_t nTot = fgknSM * nTowersPerSM ;
 164   TList *lstF = 0;
 165   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
 166     test[specie] = 0.0 ;
 167     if ( !AliQAv1::Instance()->IsEventSpecieSet(specie)) continue ;
 168     if (list[specie]->GetEntries() == 0) test[specie] = 0. ; // nothing to check
 169     else {
 170                         //get calib histos
 171                         TH2F * hdata  = (TH2F*)list[specie]->At(k2DRatioAmp) ;
 172                         TH1F * ratio = (TH1F*)list[specie]->At(kRatioDist) ;
 173
 174                         //get L1 histos
 175                         TH2F *hL1GammaPatch = (TH2F*)list[specie]->At(kGL1);
 176                         TH2F *hL1JetPatch = (TH2F*)list[specie]->At(kJL1);
 177                         TH1I *hFrameR = (TH1I*)list[specie]->At(kSTUTRU);
 178
 179                         //calib histo checker first:
 180
 181       if(hdata->GetEntries()!=0 && ratio->GetEntries()!=0) {
 182                                 //adding the lines to distinguish different SMs
 183                                 lstF = hdata->GetListOfFunctions();
 184                                 CleanListOfFunctions(lstF);
 185                                 lstF->Add(fLineCol->Clone());
 186                                 for(Int_t iLine = 0; iLine < 4; iLine++) {
 187                                         lstF->Add(fLineRow[iLine]->Clone());
 188                                 }
 189                                 //Now adding the text to for each SM
 190                                 for(Int_t iSM = 0 ; iSM < fgknSM ; iSM++){  //number of SMs loop start
 191                                         lstF->Add(fTextSM[iSM]->Clone());
 192                                 }
 193                                 //
 194                                 lstF = ratio->GetListOfFunctions();
 195                                 CleanListOfFunctions(lstF);
 196                                 //
 197                                 //now check the ratio histogram
 198                                 Double_t binContent = 0. ;
 199                                 Int_t nGoodTower = 0 ;
 200                                 Double_t rv = 0. ;
 201                                 for(Int_t ix = 1; ix <= hdata->GetNbinsX(); ix++) {
 202                                         for(Int_t iy = 1; iy <= hdata->GetNbinsY(); iy++) {
 203                                                 binContent = hdata->GetBinContent(ix, iy) ;
 204                                                 if (binContent < 1.2 && binContent > 0.8) nGoodTower++ ;
 205                                         }
 206                                 }
 207                                 rv = nGoodTower/nTot ;
 208                                 printf("%2.2f %% towers out of range [0.8, 1.2]\n", (1-rv)*100);
 209                                 if(fText){
 210                                         lstF->Add(fText->Clone()) ;
 211                                         fText->Clear() ;
 212
 213                                         fText->AddText(Form("%2.2f %% towers out of range [0.8, 1.2]", (1-rv)*100));
 214                                         if (rv < 0.9) {
 215                                                 test[specie] = 0.9 ;
 216                                                 // 2 lines text info for quality
 217                                                 fText->SetFillColor(2) ;
 218                                                 fText->AddText(Form("EMCAL = NOK, CALL EXPERTS!!!"));
 219                                         }
 220                                         else {
 221                                                 test[specie] = 0.1 ;
 222                                                 fText->SetFillColor(3) ;
 223                                                 fText->AddText(Form("EMCAL = OK, ENJOY..."));
 224                                         }
 225                                 }//fText
 226                         } // calib histo checking done
 227
 228                         //now L1 checks:
 229                         if(hL1GammaPatch->GetEntries() !=0) {
 230                                 lstF = hL1GammaPatch->GetListOfFunctions();
 231                                 CleanListOfFunctions(lstF);
 232
 233
 234                                 //Checker for L1GammaPatch (if a patch triggers > sigmaG * mean value (1/#patch positions total) says "hot spot !")
 235                                 Double_t dL1GmeanTrig = 1/2961.;
 236                                 Int_t sigmaG = 5; // deviation from mean value
 237                                 Double_t dL1GEntries = hL1GammaPatch->GetEntries();
 238                                 Int_t badL1G[48][64] = {{0}} ;
 239                                 Int_t nBadL1G = 0;
 240                                 for(Int_t ix = 1; ix <=  hL1GammaPatch->GetNbinsX(); ix++) {
 241                                         for(Int_t iy = 1; iy <=  hL1GammaPatch->GetNbinsY(); iy++) {
 242                                                 Double_t binContent = hL1GammaPatch->GetBinContent(ix, iy) ;
 243                                                 if (binContent != 0) {
 244                                                         if ((double)binContent/(double)dL1GEntries > sigmaG*dL1GmeanTrig) {
 245                                                                 badL1G[ix-1][iy-1] += 1;
 246                                                                 nBadL1G += 1;
 247                                                         }
 248                                                 }
 249                                         }
 250                                 }
 251
 252                                 if(fTextL1[0]){
 253                                         lstF->Add(fTextL1[0]->Clone()) ;
 254                                         fTextL1[0]->Clear() ;
 255
 256                                         if (nBadL1G == 0) {
 257                                                 fTextL1[0]->SetFillColor(3) ;
 258                                                 fTextL1[0]->AddText(Form("L1 GAMMA TRIGGER = OK, ENJOY..."));
 259                                         }
 260                                         else {
 261                                                 fTextL1[0]->SetFillColor(2) ;
 262                                                 fTextL1[0]->AddText(Form("HOT SPOT IN L1 GAMMA TRIGGER = CALL EXPERT!!"));
 263 /*
 264                                                 for(Int_t ix = 1; ix <=  hL1GammaPatch->GetNbinsX(); ix++) {
 265                                                         for(Int_t iy = 1; iy <=  hL1GammaPatch->GetNbinsY(); iy++) {
 266                                                                 if(badL1G[ix-1][iy-1] != 0) printf("L1 Gamma patch with position x = %d, y = %d is out of range\n",ix,iy);
 267                                                         }
 268                                                 }
 269 */
 270                                         }
 271                                 }//fTextL1[0]
 272                         }// L1 gamma patch checking done
 273
 274                         if(hL1JetPatch->GetEntries() !=0) {
 275                                 lstF = hL1JetPatch->GetListOfFunctions();
 276                                 CleanListOfFunctions(lstF);
 277
 278                                 //Checker for L1JetPatch (if a patch triggers > sigmaJ * mean value (1/#patch positions total) says "hot spot !")
 279                                 Double_t dL1JmeanTrig = 1/126.;
 280                                 Int_t sigmaJ = 5; // deviation from  mean value
 281                                 Double_t dL1JEntries = hL1JetPatch->GetEntries();
 282                                 Int_t badL1J[12][16] = {{0}} ;
 283                                 Int_t nBadL1J = 0;
 284                                 for(Int_t ix = 1; ix <=  hL1JetPatch->GetNbinsX(); ix++) {
 285                                         for(Int_t iy = 1; iy <=  hL1JetPatch->GetNbinsY(); iy++) {
 286                                                 Double_t binContent = hL1JetPatch->GetBinContent(ix, iy) ;
 287                                                 if (binContent != 0) {
 288                                                         if ((double)binContent/(double)dL1JEntries > sigmaJ*dL1JmeanTrig) {
 289                                                                 badL1J[ix-1][iy-1] += 1 ;
 290                                                                 nBadL1J += 1;
 291                                                         }
 292                                                 }
 293                                         }
 294                                 }
 295
 296                                 if(fTextL1[1]){
 297                                         lstF->Add(fTextL1[1]->Clone()) ;
 298                                         fTextL1[1]->Clear() ;
 299
 300                                         if (nBadL1J == 0) {
 301                                                 fTextL1[1]->SetFillColor(3) ;
 302                                                 fTextL1[1]->AddText(Form("L1 JET TRIGGER = OK, ENJOY..."));
 303                                         }
 304                                         else {
 305                                                 fTextL1[1]->SetFillColor(2) ;
 306                                                 fTextL1[1]->AddText(Form("HOT SPOT IN L1 JET TRIGGER = CALL EXPERT!!"));
 307 /*
 308                                                 for(Int_t ix = 1; ix <=  hL1JetPatch->GetNbinsX(); ix++) {
 309                                                         for(Int_t iy = 1; iy <=  hL1JetPatch->GetNbinsY(); iy++) {
 310                                                                 if(badL1J[ix-1][iy-1] != 0) printf("L1 Jet patch with position x = %d, y = %d is out of range\n",(4*ix-4),(4*iy-4));
 311                                                         }
 312                                                 }
 313 */
 314
 315                                         }
 316                                 }//fTextL1[1]
 317                         } // L1 Jet patch checking done
 318
 319                         if(hFrameR->GetEntries() !=0) {
 320                                 lstF = hFrameR->GetListOfFunctions();
 321                                 CleanListOfFunctions(lstF);
 322
 323                                 Int_t badLink[32] = {0};
 324                                 Int_t nBadLink = 0;
 325                                 for(Int_t ix = 1; ix <= hFrameR->GetNbinsX(); ix++) {
 326                                         Double_t binContent = hFrameR->GetBinContent(ix) ;
 327                                         if (binContent == 0) {
 328                                                 badLink[ix-1] += 1;
 329                                                 nBadLink += 1;
 330                                         }
 331                                 }
 332                                 if(fTextL1[2]){
 333                                         lstF->Add(fTextL1[2]->Clone()) ;
 334                                         fTextL1[2]->Clear() ;
 335
 336                                 if (nBadLink == 0) {
 337                                                 fTextL1[2]->SetFillColor(3) ;
 338                                                 fTextL1[2]->AddText(Form("LINK TRU-STU = OK, ENJOY..."));
 339                                         }
 340                                         else {
 341                                                 fTextL1[2]->SetFillColor(2) ;
 342                                                 fTextL1[2]->AddText(Form("PROBLEM WITH TRU-STU LINK = CALL EXPERT!!"));
 343 /*
 344                                                 for(Int_t ix = 0; ix <= hFrameR->GetNbinsX(); ix++) {
 345                                                         if(badLink[ix] != 0) printf("STU link with TRU %d is out\n",ix);
 346                                                 }
 347 */
 348                                         }
 349                                 }//fTextL1[2]
 350                         } // Checker for link TRU-STU done
 351                 }
 352
 353         }
 354 }
 355 //______________________________________________________________________________
 356
 357 void AliEMCALQAChecker::Init(const AliQAv1::DETECTORINDEX_t det)
 358 {
 359         /// intialises QA and QA checker settings
 360         AliQAv1::Instance(det) ;
 361         Float_t hiValue[AliQAv1::kNBIT] ;
 362         Float_t lowValue[AliQAv1::kNBIT] ;
 363         lowValue[AliQAv1::kINFO]      = 0.0   ;
 364         hiValue[AliQAv1::kINFO]       = 0.1 ;
 365         lowValue[AliQAv1::kWARNING]   = 0.1 ;
 366   hiValue[AliQAv1::kWARNING]    = 0.5 ;
 367         lowValue[AliQAv1::kERROR]     = 0.5   ;
 368         hiValue[AliQAv1::kERROR]      = 0.8 ;
 369         lowValue[AliQAv1::kFATAL]     = 0.8   ;
 370         hiValue[AliQAv1::kFATAL]      = 1.0 ;
 371         SetHiLo(&hiValue[0], &lowValue[0]) ;
 372 }
 373
 374 //______________________________________________________________________________
 375
 376 void AliEMCALQAChecker::CleanListOfFunctions(TList *list)
 377 { // clean up
 378
 379         if (list) {
 380                 TObject *stats = list->FindObject("stats"); list->Remove(stats);
 381                 TObject *obj;
 382                 while ((obj = list->First())) { while(list->Remove(obj)) { } delete obj; }
 383                         if (stats) list->Add(stats);
 384                 }
 385         else {
 386                 AliWarning(Form("Checker : empty list of data functions; returning"));
 387                 return;
 388         }
 389
 390 }
 391
 392