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 "AliQAv1.h"
  36 #include "AliQAChecker.h"
  37 #include "AliVZEROQAChecker.h"
  38 #include "AliVZEROQADataMakerRec.h"
  39 //#include "AliCDBEntry.h"
  40 //#include "AliCDBManager.h"
  41
  42 ClassImp(AliVZEROQAChecker)
  43
  44 //__________________________________________________________________
  45 void AliVZEROQAChecker::Check(Double_t * check, AliQAv1::ALITASK_t index, TObjArray ** list, const AliDetectorRecoParam * /*recoParam*/)
  46 {
  47
  48 // Main check function: Depending on the TASK, different checks will be applied
  49 // Check for empty histograms
  50
  51 //   AliDebug(AliQAv1::GetQADebugLevel(),Form("AliVZEROChecker"));
  52 //   AliCDBEntry *QARefRec = AliCDBManager::Instance()->Get("VZERO/QARef/RAW");
  53 //   if( !QARefRec){
  54 //     AliDebug(AliQAv1::GetQADebugLevel(), "QA reference data NOT retrieved for QA check...");
  55 //     return 1.;
  56 //   }
  57
  58 //   Check that histos are filled - (FATAL) set if empty
  59   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
  60     check[specie]    = 1.0 ;
  61     if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
  62       continue ;
  63     if(CheckEntries(list[specie]) == 0.0){
  64         check[specie] =  CheckEntries(list[specie]);
  65     } else {
  66       //   Check for one disk missing (FATAL) or one ring missing (ERROR) in ESDs
  67       if(index == AliQAv1::kESD)
  68           check[specie] =  CheckEsds(list[specie]);
  69     }
  70   }
  71 }
  72
  73 //_________________________________________________________________
  74 Double_t AliVZEROQAChecker::CheckEntries(TObjArray * list) const
  75 {
  76
  77   //  check on the QA histograms on the input list: list
  78 //  list->Print();
  79
  80   Double_t test = 0.0 ;
  81   Int_t   count = 0 ;
  82
  83   if (list->GetEntries() == 0){
  84         test = 1.0;
  85     AliDebug(AliQAv1::GetQADebugLevel(), Form("There are NO ENTRIES to be checked..."));
  86   } else {
  87         TIter next(list) ;
  88         TH1 * hdata ;
  89         count = 0 ;
  90         while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
  91                 if (hdata) {
  92                         Double_t rv = 0.0;
  93                         if(hdata->GetEntries()>0) rv=1.0;
  94 //         AliDebug(AliQAv1::GetQADebugLevel(), Form("%s -> %f", hdata->GetName(), rv));
  95                         count++ ;        // number of histos
  96                         test += rv ;     // number of histos filled
  97         }else{
  98                         AliError(Form("Data type cannot be processed"));
  99         }
 100         }
 101         if (count != 0) {
 102                 if (test==0.0) {
 103                         AliWarning(Form("Histograms are BOOKED for this specific task, but they are all EMPTY"));
 104                 } else {
 105                         test /= count;
 106                 }
 107         }
 108   }
 109   return test ;
 110 }
 111
 112 //_________________________________________________________________
 113 Double_t AliVZEROQAChecker::CheckEsds(TObjArray * list) const
 114 {
 115
 116 //  check the ESDs for missing disk or ring
 117
 118 //  printf(" Number of entries in ESD list = %d\n", list->GetEntries());
 119 //  list->Print();
 120
 121   Double_t test     = 1.0;     // initialisation to OK
 122   Int_t    histonb =   0;
 123   Double_t multV0A = 0.0;
 124   Double_t multV0C = 0.0;
 125   Double_t v0ABBRing[4], v0CBBRing[4];
 126   Double_t v0ABGRing[4], v0CBGRing[4];
 127   for (Int_t i=0; i<4; i++) {
 128        v0ABBRing[i]= v0CBBRing[i]= 0.0;
 129        v0ABGRing[i]= v0CBGRing[i]= 0.0;
 130   }
 131   TIter next(list) ;
 132   TH1 * hdata ;
 133
 134   while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
 135           if (hdata) {
 136                   switch (histonb) {
 137                   case AliVZEROQADataMakerRec::kCellMultiV0A:
 138                           multV0A  = hdata->GetMean();
 139                           break;
 140                   case AliVZEROQADataMakerRec::kCellMultiV0C:
 141                           multV0C  = hdata->GetMean();
 142                           break;
 143                   case AliVZEROQADataMakerRec::kBBFlag:
 144                   for (Int_t i=0; i<8; i++) {
 145                                   if(i<4) v0CBBRing[i]  = hdata->Integral((i*8)+1, (i*8) +8);
 146                                   else v0ABBRing[i-4]  = hdata->Integral((i*8)+1, (i*8) +8);
 147                           }
 148                           break;
 149                   case AliVZEROQADataMakerRec::kBGFlag:
 150                   for (Int_t i=0; i<8; i++) {
 151                                   if(i<4) v0CBGRing[i]  = hdata->Integral((i*8)+1, (i*8) +8);
 152                                   else v0ABGRing[i-4]  = hdata->Integral((i*8)+1, (i*8) +8);
 153                           }
 154                           break;
 155                   }
 156           }
 157           histonb++;
 158   }
 159
 160   if(multV0A == 0.0 || multV0C == 0.0) {
 161      AliWarning(Form("One of the two disks is missing !") );
 162      test = 0.0; // bit FATAL set
 163   }
 164   if( v0ABBRing[0]+v0ABGRing[0] == 0.0 ||
 165       v0ABBRing[1]+v0ABGRing[1] == 0.0 ||
 166       v0ABBRing[2]+v0ABGRing[2] == 0.0 ||
 167       v0ABBRing[3]+v0ABGRing[3] == 0.0 ||
 168       v0CBBRing[0]+v0CBGRing[0] == 0.0 ||
 169       v0CBBRing[1]+v0CBGRing[1] == 0.0 ||
 170       v0CBBRing[2]+v0CBGRing[2] == 0.0 ||
 171       v0CBBRing[3]+v0CBGRing[3] == 0.0  ){
 172       AliWarning(Form("One ring is missing !") );
 173       test = 0.1;   // bit ERROR set
 174   }
 175
 176   return test ;
 177 }
 178
 179 //______________________________________________________________________________
 180 void AliVZEROQAChecker::Init(const AliQAv1::DETECTORINDEX_t det)
 181 {
 182   // intialises QA and QA checker settings
 183   AliQAv1::Instance(det) ;
 184   Float_t * hiValue = new Float_t[AliQAv1::kNBIT] ;
 185   Float_t * lowValue = new Float_t[AliQAv1::kNBIT] ;
 186   lowValue[AliQAv1::kINFO]      = 0.5   ;
 187   hiValue[AliQAv1::kINFO]       = 1.0 ;
 188   lowValue[AliQAv1::kWARNING]   = 0.2 ;
 189   hiValue[AliQAv1::kWARNING]    = 0.5 ;
 190   lowValue[AliQAv1::kERROR]     = 0.0   ;
 191   hiValue[AliQAv1::kERROR]      = 0.2 ;
 192   lowValue[AliQAv1::kFATAL]     = -1.0   ;
 193   hiValue[AliQAv1::kFATAL]      = 0.0 ;
 194   SetHiLo(hiValue, lowValue) ;
 195   delete [] hiValue;
 196   delete [] lowValue;
 197 }
 198
 199 //______________________________________________________________________________
 200 void AliVZEROQAChecker::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
 201 {
 202 // sets the QA word according to return value of the Check
 203   AliQAv1 * qa = AliQAv1::Instance(index);
 204   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
 205     qa->UnSet(AliQAv1::kFATAL, specie);
 206     qa->UnSet(AliQAv1::kWARNING, specie);
 207     qa->UnSet(AliQAv1::kERROR, specie);
 208     qa->UnSet(AliQAv1::kINFO, specie);
 209     if ( ! value ) { // No checker is implemented, set all QA to Fatal
 210       qa->Set(AliQAv1::kFATAL, specie) ;
 211     } else {
 212       if ( value[specie] >= fLowTestValue[AliQAv1::kFATAL] && value[specie] < fUpTestValue[AliQAv1::kFATAL] )
 213         qa->Set(AliQAv1::kFATAL, specie) ;
 214       else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] && value[specie] <= fUpTestValue[AliQAv1::kERROR]  )
 215         qa->Set(AliQAv1::kERROR, specie) ;
 216       else if ( value[specie] > fLowTestValue[AliQAv1::kWARNING] && value[specie] <= fUpTestValue[AliQAv1::kWARNING]  )
 217         qa->Set(AliQAv1::kWARNING, specie) ;
 218       else if ( value[specie] > fLowTestValue[AliQAv1::kINFO] && value[specie] <= fUpTestValue[AliQAv1::kINFO] )
 219         qa->Set(AliQAv1::kINFO, specie) ;
 220     }
 221   }
 222 }
 223