VZERO/AliVZEROQAChecker.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 /*
  18   Checks the quality assurance. Under construction.
  19   By comparing with reference data
  20
  21 */
  22
  23 // --- ROOT system ---
  24 #include <TClass.h>
  25 #include <TH1F.h>
  26 #include <TH1I.h>
  27 #include <TIterator.h>
  28 #include <TKey.h>
  29 #include <TFile.h>
  30
  31 // --- Standard library ---
  32
  33 // --- AliRoot header files ---
  34 #include "AliLog.h"
  35 #include "AliQA.h"
  36 #include "AliQAChecker.h"
  37 #include "AliVZEROQAChecker.h"
  38 //#include "AliCDBEntry.h"
  39 //#include "AliCDBManager.h"
  40
  41 ClassImp(AliVZEROQAChecker)
  42
  43 //__________________________________________________________________
  44 const Double_t AliVZEROQAChecker::Check(AliQA::ALITASK_t index, TObjArray * list)
  45 {
  46
  47 // Main check function: Depending on the TASK, different checks will be applied
  48 // Check for empty histograms
  49
  50 //   AliDebug(1,Form("AliVZEROChecker"));
  51 //   AliCDBEntry *QARefRec = AliCDBManager::Instance()->Get("VZERO/QARef/RAW");
  52 //   if( !QARefRec){
  53 //     AliInfo("QA reference data NOT retrieved for QA check...");
  54 //     return 1.;
  55 //   }
  56
  57 //   Check that histos are filled - (FATAL) set if empty
  58      if(CheckEntries(list) == 0.0){
  59         return CheckEntries(list);
  60      }
  61
  62 //   Check for one disk missing (FATAL) or one ring missing (ERROR) in ESDs
  63      if(index == AliQA::kESD) {
  64         return CheckEsds(list);
  65      }
  66
  67      return 1.0;
  68 }
  69 //_________________________________________________________________
  70 Double_t AliVZEROQAChecker::CheckEntries(TObjArray * list) const
  71 {
  72
  73   //  check on the QA histograms on the input list: list
  74 //  list->Print();
  75
  76   Double_t test = 0.0 ;
  77   Int_t   count = 0 ;
  78
  79   if (list->GetEntries() == 0){
  80       test = 1.0;
  81       AliInfo(Form("There are NO ENTRIES to be checked..."));
  82   }
  83   else {
  84       TIter next(list) ;
  85       TH1 * hdata ;
  86       count = 0 ;
  87       while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
  88         if (hdata) {
  89            Double_t rv = 0.0;
  90            if(hdata->GetEntries()>0) rv=1.0;
  91 //         AliInfo(Form("%s -> %f", hdata->GetName(), rv));
  92            count++ ;        // number of histos
  93            test += rv ;     // number of histos filled
  94         }
  95         else{
  96            AliError(Form("Data type cannot be processed"));
  97         }
  98       }
  99       if (count != 0) {
 100           if (test==0.0) {
 101               AliWarning(Form("Histograms are BOOKED for this specific task, but they are all EMPTY"));
 102           }
 103           else {
 104               test /= count;
 105           }
 106       }
 107   }
 108   return test ;
 109 }
 110
 111 //_________________________________________________________________
 112 Double_t AliVZEROQAChecker::CheckEsds(TObjArray * list) const
 113 {
 114
 115 //  check the ESDs for missing disk or ring
 116
 117 //  printf(" Number of entries in ESD list = %d\n", list->GetEntries());
 118 //  list->Print();
 119
 120   Double_t test     = 1.0;     // initialisation to OK
 121   Int_t    histo_nb =   0;
 122   Double_t Mult_V0A = 0.0;
 123   Double_t Mult_V0C = 0.0;
 124   Double_t V0A_BB_Ring[4], V0C_BB_Ring[4];
 125   Double_t V0A_BG_Ring[4], V0C_BG_Ring[4];
 126   for (Int_t i=0; i<4; i++) {
 127        V0A_BB_Ring[i]= V0C_BB_Ring[i]= 0.0;
 128        V0A_BG_Ring[i]= V0C_BG_Ring[i]= 0.0;
 129   }
 130   TIter next(list) ;
 131   TH1 * hdata ;
 132
 133   while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
 134           if (hdata) {
 135               histo_nb++;
 136               if (histo_nb == 3) {
 137                   Mult_V0A  = hdata->GetMean();
 138 //                printf(" Histo ESD number %d; Mean Mult on V0A = %f\n",histo_nb, Mult_V0A);
 139               }
 140               if (histo_nb == 4) {
 141                   Mult_V0C  = hdata->GetMean();
 142 //                printf(" Histo ESD number %d; Mean Mult on V0C = %f\n",histo_nb, Mult_V0C);
 143               }
 144               if (histo_nb == 6) {
 145                   for (Int_t i=0; i<4; i++) {
 146                        V0A_BB_Ring[i]  = hdata->Integral((i*8)+1, (i*8) +8);
 147 //                     printf(" Histo ESD number %d; Ring = %d; BB A %f\n",histo_nb, i, V0A_BB_Ring[i]);
 148                   }
 149               }
 150               if (histo_nb == 7) {
 151                   for (Int_t i=0; i<4; i++) {
 152                        V0A_BG_Ring[i]  = hdata->Integral((i*8)+1, (i*8) +8);
 153 //                     printf(" Histo ESD number %d; Ring = %d; BG A %f\n",histo_nb, i, V0A_BG_Ring[i]);
 154                   }
 155               }
 156               if (histo_nb == 8) {
 157                   for (Int_t i=0; i<4; i++) {
 158                        V0C_BB_Ring[i]  = hdata->Integral((i*8)+1, (i*8) +8);
 159 //                     printf(" Histo ESD number %d; Ring = %d; BB C %f\n",histo_nb, i, V0C_BB_Ring[i]);
 160                   }
 161               }
 162               if (histo_nb == 9) {
 163                   for (Int_t i=0; i<4; i++) {
 164                        V0C_BG_Ring[i]  = hdata->Integral((i*8)+1, (i*8) +8);
 165 //                     printf(" Histo ESD number %d; Ring = %d; BG C %f\n",histo_nb, i, V0C_BG_Ring[i]);
 166                   }
 167               }
 168           }
 169   }
 170
 171   if(Mult_V0A == 0.0 || Mult_V0C == 0.0) {
 172      AliWarning(Form("One of the two disks is missing !") );
 173      test = 0.0; // bit FATAL set
 174   }
 175   if( V0A_BB_Ring[0]+V0A_BG_Ring[0] == 0.0 ||
 176       V0A_BB_Ring[1]+V0A_BG_Ring[1] == 0.0 ||
 177       V0A_BB_Ring[2]+V0A_BG_Ring[2] == 0.0 ||
 178       V0A_BB_Ring[3]+V0A_BG_Ring[3] == 0.0 ||
 179       V0C_BB_Ring[0]+V0C_BG_Ring[0] == 0.0 ||
 180       V0C_BB_Ring[1]+V0C_BG_Ring[1] == 0.0 ||
 181       V0C_BB_Ring[2]+V0C_BG_Ring[2] == 0.0 ||
 182       V0C_BB_Ring[3]+V0C_BG_Ring[3] == 0.0  ){
 183       AliWarning(Form("One ring is missing !") );
 184       test = 0.1;   // bit ERROR set
 185   }
 186
 187   return test ;
 188 }
 189
 190 //______________________________________________________________________________
 191 void AliVZEROQAChecker::SetQA(AliQA::ALITASK_t index, const Double_t value) const
 192 {
 193 // sets the QA word according to return value of the Check
 194
 195   AliQA * qa = AliQA::Instance(index);
 196
 197   qa->UnSet(AliQA::kFATAL);
 198   qa->UnSet(AliQA::kWARNING);
 199   qa->UnSet(AliQA::kERROR);
 200   qa->UnSet(AliQA::kINFO);
 201
 202   if ( value <= 0.0 ) qa->Set(AliQA::kFATAL) ;
 203   else if ( value > 0.0 && value <= 0.2 ) qa->Set(AliQA::kERROR) ;
 204   else if ( value > 0.2 && value <= 0.5 ) qa->Set(AliQA::kWARNING) ;
 205   else if ( value > 0.5 && value < 1.0 ) qa->Set(AliQA::kINFO) ;
 206 }
 207