Macro to calculate the needed HV values as a function of the required MIP signal.
[u/mrichter/AliRoot.git] / VZERO / AliVZEROQAChecker.cxx
index ec81c30..a14f743 100644 (file)
@@ -32,7 +32,7 @@
 
 // --- AliRoot header files ---
 #include "AliLog.h"
-#include "AliQA.h"
+#include "AliQAv1.h"
 #include "AliQAChecker.h"
 #include "AliVZEROQAChecker.h"
 #include "AliVZEROQADataMakerRec.h"
 
 ClassImp(AliVZEROQAChecker)
 
-//____________________________________________________________________________
-Double_t * AliVZEROQAChecker::Check(AliQA::ALITASK_t /*index*/)
-{
-  Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ; 
-  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
-    rv[specie] = 0.0 ; 
-  return rv ;  
-}
-
 //__________________________________________________________________
-Double_t * AliVZEROQAChecker::Check(AliQA::ALITASK_t index, TObjArray ** list) 
+void AliVZEROQAChecker::Check(Double_t * check, AliQAv1::ALITASK_t index, TObjArray ** list, const AliDetectorRecoParam * /*recoParam*/) 
 {
 
 // Main check function: Depending on the TASK, different checks will be applied
 // Check for empty histograms 
 
-//   AliDebug(1,Form("AliVZEROChecker"));
+//   AliDebug(AliQAv1::GetQADebugLevel(),Form("AliVZEROChecker"));
 //   AliCDBEntry *QARefRec = AliCDBManager::Instance()->Get("VZERO/QARef/RAW");
 //   if( !QARefRec){
-//     AliInfo("QA reference data NOT retrieved for QA check...");
+//     AliDebug(AliQAv1::GetQADebugLevel(), "QA reference data NOT retrieved for QA check...");
 //     return 1.;
 //   }
 
 //   Check that histos are filled - (FATAL) set if empty
-  Double_t * check = new Double_t[AliRecoParam::kNSpecies] ; 
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
     check[specie]    = 1.0 ; 
-    if ( !AliQA::Instance()->IsEventSpecieSet(specie) ) 
+    if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) 
       continue ; 
     if(CheckEntries(list[specie]) == 0.0){
         check[specie] =  CheckEntries(list[specie]);
     } else {
       //   Check for one disk missing (FATAL) or one ring missing (ERROR) in ESDs     
-      if(index == AliQA::kESD) 
+      if(index == AliQAv1::kESD) 
           check[specie] =  CheckEsds(list[specie]);
     } 
   }
-  return check; 
 }
 
 //_________________________________________________________________
@@ -93,7 +82,7 @@ Double_t AliVZEROQAChecker::CheckEntries(TObjArray * list) const
 
   if (list->GetEntries() == 0){  
        test = 1.0; 
-       AliInfo(Form("There are NO ENTRIES to be checked..."));
+    AliDebug(AliQAv1::GetQADebugLevel(), Form("There are NO ENTRIES to be checked..."));
   } else {
        TIter next(list) ; 
        TH1 * hdata ;
@@ -102,7 +91,7 @@ Double_t AliVZEROQAChecker::CheckEntries(TObjArray * list) const
                if (hdata) {       
                        Double_t rv = 0.0;
                        if(hdata->GetEntries()>0) rv=1.0;
-//        AliInfo(Form("%s -> %f", hdata->GetName(), rv)); 
+//        AliDebug(AliQAv1::GetQADebugLevel(), Form("%s -> %f", hdata->GetName(), rv)); 
                        count++ ;        // number of histos
                        test += rv ;     // number of histos filled
         }else{
@@ -130,56 +119,56 @@ Double_t AliVZEROQAChecker::CheckEsds(TObjArray * list) const
 //  list->Print();
 
   Double_t test     = 1.0;     // initialisation to OK
-  Int_t    histo_nb =   0; 
-  Double_t Mult_V0A = 0.0;
-  Double_t Mult_V0C = 0.0;
-  Double_t V0A_BB_Ring[4], V0C_BB_Ring[4];
-  Double_t V0A_BG_Ring[4], V0C_BG_Ring[4];
+  Int_t    histonb =   0; 
+  Double_t multV0A = 0.0;
+  Double_t multV0C = 0.0;
+  Double_t v0ABBRing[4], v0CBBRing[4];
+  Double_t v0ABGRing[4], v0CBGRing[4];
   for (Int_t i=0; i<4; i++) { 
-       V0A_BB_Ring[i]= V0C_BB_Ring[i]= 0.0;
-       V0A_BG_Ring[i]= V0C_BG_Ring[i]= 0.0;
+       v0ABBRing[i]= v0CBBRing[i]= 0.0;
+       v0ABGRing[i]= v0CBGRing[i]= 0.0;
   }  
   TIter next(list) ; 
   TH1 * hdata ;
   
   while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
          if (hdata) {
-                 switch (histo_nb) {
+                 switch (histonb) {
                  case AliVZEROQADataMakerRec::kCellMultiV0A:
-                         Mult_V0A  = hdata->GetMean();
+                         multV0A  = hdata->GetMean();
                          break;
                  case AliVZEROQADataMakerRec::kCellMultiV0C:
-                         Mult_V0C  = hdata->GetMean();
+                         multV0C  = hdata->GetMean();
                          break;
                  case AliVZEROQADataMakerRec::kBBFlag:
                  for (Int_t i=0; i<8; i++) {         
-                                 if(i<4) V0C_BB_Ring[i]  = hdata->Integral((i*8)+1, (i*8) +8);
-                                 else V0A_BB_Ring[i-4]  = hdata->Integral((i*8)+1, (i*8) +8);
+                                 if(i<4) v0CBBRing[i]  = hdata->Integral((i*8)+1, (i*8) +8);
+                                 else v0ABBRing[i-4]  = hdata->Integral((i*8)+1, (i*8) +8);
                          }           
                          break;
                  case AliVZEROQADataMakerRec::kBGFlag:
                  for (Int_t i=0; i<8; i++) {         
-                                 if(i<4) V0C_BG_Ring[i]  = hdata->Integral((i*8)+1, (i*8) +8);
-                                 else V0A_BG_Ring[i-4]  = hdata->Integral((i*8)+1, (i*8) +8);
+                                 if(i<4) v0CBGRing[i]  = hdata->Integral((i*8)+1, (i*8) +8);
+                                 else v0ABGRing[i-4]  = hdata->Integral((i*8)+1, (i*8) +8);
                          }           
                          break;
                  }
          }
-         histo_nb++;
+         histonb++;
   }
   
-  if(Mult_V0A == 0.0 || Mult_V0C == 0.0) {
+  if(multV0A == 0.0 || multV0C == 0.0) {
      AliWarning(Form("One of the two disks is missing !") );
      test = 0.0; // bit FATAL set
   }
-  if( V0A_BB_Ring[0]+V0A_BG_Ring[0] == 0.0 || 
-      V0A_BB_Ring[1]+V0A_BG_Ring[1] == 0.0 || 
-      V0A_BB_Ring[2]+V0A_BG_Ring[2] == 0.0 || 
-      V0A_BB_Ring[3]+V0A_BG_Ring[3] == 0.0 || 
-      V0C_BB_Ring[0]+V0C_BG_Ring[0] == 0.0 || 
-      V0C_BB_Ring[1]+V0C_BG_Ring[1] == 0.0 || 
-      V0C_BB_Ring[2]+V0C_BG_Ring[2] == 0.0 || 
-      V0C_BB_Ring[3]+V0C_BG_Ring[3] == 0.0  ){    
+  if( v0ABBRing[0]+v0ABGRing[0] == 0.0 || 
+      v0ABBRing[1]+v0ABGRing[1] == 0.0 || 
+      v0ABBRing[2]+v0ABGRing[2] == 0.0 || 
+      v0ABBRing[3]+v0ABGRing[3] == 0.0 || 
+      v0CBBRing[0]+v0CBGRing[0] == 0.0 || 
+      v0CBBRing[1]+v0CBGRing[1] == 0.0 || 
+      v0CBBRing[2]+v0CBGRing[2] == 0.0 || 
+      v0CBBRing[3]+v0CBGRing[3] == 0.0  ){    
       AliWarning(Form("One ring is missing !") );
       test = 0.1;   // bit ERROR set
   }
@@ -188,44 +177,46 @@ Double_t AliVZEROQAChecker::CheckEsds(TObjArray * list) const
 } 
 
 //______________________________________________________________________________
-void AliVZEROQAChecker::Init(const AliQA::DETECTORINDEX_t det) 
+void AliVZEROQAChecker::Init(const AliQAv1::DETECTORINDEX_t det) 
 {
   // intialises QA and QA checker settings
-  AliQA::Instance(det) ; 
-  Float_t * hiValue = new Float_t[AliQA::kNBIT] ; 
-  Float_t * lowValue = new Float_t[AliQA::kNBIT] ;
-  lowValue[AliQA::kINFO]      = 0.5   ; 
-  hiValue[AliQA::kINFO]       = 1.0 ; 
-  lowValue[AliQA::kWARNING]   = 0.2 ; 
-  hiValue[AliQA::kWARNING]    = 0.5 ; 
-  lowValue[AliQA::kERROR]     = 0.0   ; 
-  hiValue[AliQA::kERROR]      = 0.2 ; 
-  lowValue[AliQA::kFATAL]     = -1.0   ; 
-  hiValue[AliQA::kFATAL]      = 0.0 ; 
+  AliQAv1::Instance(det) ; 
+  Float_t * hiValue = new Float_t[AliQAv1::kNBIT] ; 
+  Float_t * lowValue = new Float_t[AliQAv1::kNBIT] ;
+  lowValue[AliQAv1::kINFO]      = 0.5   ; 
+  hiValue[AliQAv1::kINFO]       = 1.0 ; 
+  lowValue[AliQAv1::kWARNING]   = 0.2 ; 
+  hiValue[AliQAv1::kWARNING]    = 0.5 ; 
+  lowValue[AliQAv1::kERROR]     = 0.0   ; 
+  hiValue[AliQAv1::kERROR]      = 0.2 ; 
+  lowValue[AliQAv1::kFATAL]     = -1.0   ; 
+  hiValue[AliQAv1::kFATAL]      = 0.0 ; 
   SetHiLo(hiValue, lowValue) ; 
+  delete [] hiValue;
+  delete [] lowValue;
 }
 
 //______________________________________________________________________________
-void AliVZEROQAChecker::SetQA(AliQA::ALITASK_t index, Double_t * value) const
+void AliVZEROQAChecker::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
 {
 // sets the QA word according to return value of the Check
-  AliQA * qa = AliQA::Instance(index);
+  AliQAv1 * qa = AliQAv1::Instance(index);
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
-    qa->UnSet(AliQA::kFATAL, specie);
-    qa->UnSet(AliQA::kWARNING, specie);
-    qa->UnSet(AliQA::kERROR, specie);
-    qa->UnSet(AliQA::kINFO, specie);
+    qa->UnSet(AliQAv1::kFATAL, specie);
+    qa->UnSet(AliQAv1::kWARNING, specie);
+    qa->UnSet(AliQAv1::kERROR, specie);
+    qa->UnSet(AliQAv1::kINFO, specie);
     if ( ! value ) { // No checker is implemented, set all QA to Fatal
-      qa->Set(AliQA::kFATAL, specie) ; 
+      qa->Set(AliQAv1::kFATAL, specie) ; 
     } else {
-      if ( value[specie] >= fLowTestValue[AliQA::kFATAL] && value[specie] < fUpTestValue[AliQA::kFATAL] ) 
-        qa->Set(AliQA::kFATAL, specie) ; 
-      else if ( value[specie] > fLowTestValue[AliQA::kERROR] && value[specie] <= fUpTestValue[AliQA::kERROR]  )
-        qa->Set(AliQA::kERROR, specie) ; 
-      else if ( value[specie] > fLowTestValue[AliQA::kWARNING] && value[specie] <= fUpTestValue[AliQA::kWARNING]  )
-        qa->Set(AliQA::kWARNING, specie) ;
-      else if ( value[specie] > fLowTestValue[AliQA::kINFO] && value[specie] <= fUpTestValue[AliQA::kINFO] ) 
-        qa->Set(AliQA::kINFO, specie) ;        
+      if ( value[specie] >= fLowTestValue[AliQAv1::kFATAL] && value[specie] < fUpTestValue[AliQAv1::kFATAL] ) 
+        qa->Set(AliQAv1::kFATAL, specie) ; 
+      else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] && value[specie] <= fUpTestValue[AliQAv1::kERROR]  )
+        qa->Set(AliQAv1::kERROR, specie) ; 
+      else if ( value[specie] > fLowTestValue[AliQAv1::kWARNING] && value[specie] <= fUpTestValue[AliQAv1::kWARNING]  )
+        qa->Set(AliQAv1::kWARNING, specie) ;
+      else if ( value[specie] > fLowTestValue[AliQAv1::kINFO] && value[specie] <= fUpTestValue[AliQAv1::kINFO] ) 
+        qa->Set(AliQAv1::kINFO, specie) ;      
     }
   }
 }