Always delete TObjArrays created by TString::Tokenize (Ruben)
[u/mrichter/AliRoot.git] / MUON / AliMUONTriggerQAChecker.cxx
index f60840a..5ff45df 100644 (file)
@@ -72,11 +72,7 @@ AliMUONTriggerQAChecker::CheckRaws(TObjArray** list, const AliMUONRecoParam* )
 {
   /// Check raw data
 
-  AliMUONVQAChecker::ECheckCode * rv = new AliMUONVQAChecker::ECheckCode[AliRecoParam::kNSpecies] ; 
-
-  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
-    rv[specie] = AliMUONVQAChecker::kInfo; 
-  }
+  AliMUONVQAChecker::ECheckCode * rv = new AliMUONVQAChecker::ECheckCode[AliRecoParam::kNSpecies];
 
   Int_t histoRawsPercentIndex[] = {
     AliMUONQAIndices::kTriggerErrorSummaryNorm, 
@@ -85,51 +81,84 @@ AliMUONTriggerQAChecker::CheckRaws(TObjArray** list, const AliMUONRecoParam* )
   };
   const Int_t kNrawsHistos = sizeof(histoRawsPercentIndex)/sizeof(histoRawsPercentIndex[0]);
 
-  // MOVE THESE TO REFERENCE HISTOS
-// START WITH THOSE COMMENTED OUT UNTIL WE GAIN CONFIDENCE...
-//  Float_t safeFactor = 5.;
-//  Float_t alarmPercentTrigAlgo[AliMUONTriggerQADataMakerRec::kNtrigAlgoErrorBins] = {safeFactor*1., safeFactor*1., safeFactor*1., 100., 100., 100., 100., safeFactor*1., safeFactor*1., safeFactor*1.};
-//  Float_t alarmPercentCalib[AliMUONTriggerQADataMakerRec::kNtrigCalibSummaryBins] = {safeFactor*0.4, safeFactor*1., 6.2, 0.0001, safeFactor*0.4};
-//  Float_t alarmPercentReadout[AliMUONTriggerQADataMakerRec::kNtrigStructErrorBins] = {safeFactor*1., safeFactor*1., safeFactor*1., safeFactor*1.};
-//
-//  Float_t* alarmPercent[kNrawsHistos] = {alarmPercentTrigAlgo, alarmPercentCalib, alarmPercentReadout};
-// END OF COWARD COMMENTING...
+  // BEGIN OF LIMITS
+  // Fixme: Move me to reference histos
+  Float_t safeFactor = 5.;
+  Float_t warningPercentTrigAlgo[AliMUONQAIndices::kNtrigAlgoErrorBins] = {safeFactor*1., safeFactor*1., safeFactor*1., 100., 100., 100., 100., safeFactor*1., safeFactor*1., safeFactor*1.};
+  Float_t warningPercentCalib[AliMUONQAIndices::kNtrigCalibSummaryBins] = {safeFactor*0.4, safeFactor*1., 3.1, 0.0001, safeFactor*0.4};
+  Float_t warningPercentReadout[AliMUONQAIndices::kNtrigStructErrorBins] = {safeFactor*1., safeFactor*1., safeFactor*1., safeFactor*1.};
+
+  Float_t* warningPercent[kNrawsHistos] = {warningPercentTrigAlgo, warningPercentCalib, warningPercentReadout};
   
+  Float_t errorFactor = 30.;
+  Float_t errorPercentTrigAlgo[AliMUONQAIndices::kNtrigAlgoErrorBins] = {errorFactor*1., errorFactor*1., errorFactor*1., 100., 100., 100., 100., errorFactor*1., errorFactor*1., errorFactor*1.};
+  Float_t errorPercentCalib[AliMUONQAIndices::kNtrigCalibSummaryBins] = {errorFactor*0.4, errorFactor*1., 6.2, 3.*0.0001, errorFactor*0.4};
+  Float_t errorPercentReadout[AliMUONQAIndices::kNtrigStructErrorBins] = {errorFactor*1., errorFactor*1., errorFactor*1., errorFactor*1.};
+  // END OF LIMTS
+
+  Float_t* errorPercent[kNrawsHistos] = {errorPercentTrigAlgo, errorPercentCalib, errorPercentReadout};
+  
+  TObjArray messages;
+  messages.SetOwner(kTRUE);
+
   TH1* currHisto = 0x0;
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+    rv[specie] = AliMUONVQAChecker::kInfo;
+
     TH1* hAnalyzedEvents = AliQAv1::GetData(list,AliMUONQAIndices::kTriggerRawNAnalyzedEvents,AliRecoParam::ConvertIndex(specie));
-    Int_t nAnalyzedEvents = 0;
-    if ( hAnalyzedEvents ) 
-      nAnalyzedEvents = hAnalyzedEvents->GetBinContent(1);
+
+    //if ( nAnalyzedEvents == 0 ) rv[specie] = AliMUONVQAChecker::kFatal;
+
     for(Int_t ihisto = 0; ihisto<kNrawsHistos; ihisto++){
+      Int_t nAnalyzedEvents = 0;
+      Int_t ibinNevents = ( histoRawsPercentIndex[ihisto] == AliMUONQAIndices::kTriggerReadOutErrorsNorm ) ? 1 : 2;
+      if ( hAnalyzedEvents ) nAnalyzedEvents = TMath::Nint(hAnalyzedEvents->GetBinContent(ibinNevents));
+      AliMUONVQAChecker::ECheckCode currRv = AliMUONVQAChecker::kInfo;
+      messages.Clear();
       currHisto = AliQAv1::GetData(list,histoRawsPercentIndex[ihisto],AliRecoParam::ConvertIndex(specie));
-      if ( currHisto ){
-       currHisto->SetBarWidth(0.5);
-       currHisto->SetBarOffset(0.25);
-       TPaveText* text = new TPaveText(0.65,0.65,0.99,0.99,"NDC");
-       TString binName;
-       Bool_t isOk = kTRUE;
-       Int_t nbins = currHisto->GetXaxis()->GetNbins();
-       for (Int_t ibin = 1; ibin<=nbins; ibin++){
-         binName = currHisto->GetXaxis()->GetBinLabel(ibin);
-         binName.ReplaceAll("#splitline","");
-         binName.ReplaceAll("{","");
-         binName.ReplaceAll("}","");
-         Float_t binContent = currHisto->GetBinContent(ibin);
-//       if (binContent > alarmPercent[ihisto][ibin-1]) isOk = kFALSE;
-         text->AddText(Form("%5.2f %% in %s", binContent, binName.Data()));
-         //text->AddText(Form("%5.2f %% in %s (limit %5.2f %%)", binContent, binName.Data(), alarmPercent[ihisto][ibin-1]));
+      if ( ! currHisto ) continue;
+
+      Int_t nbins = currHisto->GetXaxis()->GetNbins();
+      for (Int_t ibin = 1; ibin<=nbins; ibin++){
+        Double_t binContent = currHisto->GetBinContent(ibin);
+        if ( binContent > errorPercent[ihisto][ibin-1] )
+          currRv = AliMUONVQAChecker::kError;
+        else if ( binContent > warningPercent[ihisto][ibin-1] )
+          currRv = AliMUONVQAChecker::kWarning;
+        else if ( ibin == 4 && binContent > 50. && AliRecoParam::ConvertIndex(specie) == AliRecoParam::kCalib) {
+          messages.Add(new TObjString("Do not panic:")); 
+          messages.Add(new TObjString("copy errors do not affect data"));
+        }
+      } // loop on bins
+      if ( currRv != AliMUONVQAChecker::kInfo ) {
+       switch ( histoRawsPercentIndex[ihisto] ) {
+       case AliMUONQAIndices::kTriggerErrorSummaryNorm:
+       case AliMUONQAIndices::kTriggerCalibSummaryNorm:
+         messages.Add(new TObjString("Trigger algo errors"));
+         break;
+       case AliMUONQAIndices::kTriggerReadOutErrorsNorm:
+         messages.Add(new TObjString("Readout errors"));
+         break;
        }
-       text->AddText(Form("Total events %i", nAnalyzedEvents));
-       if ( ! isOk || nAnalyzedEvents == 0 ) {
-         text->SetFillColor(kRed);
-         rv[specie] = MarkHisto(*currHisto, AliMUONVQAChecker::kError);
+       if ( currRv == AliMUONVQAChecker::kWarning )
+         messages.Add(new TObjString("are a little bit high"));
+       else if ( currRv == AliMUONVQAChecker::kError || 
+                 currRv == AliMUONVQAChecker::kFatal )
+         messages.Add(new TObjString("are too high"));
+      }
+      else if ( nAnalyzedEvents != 0 ) {
+       switch ( histoRawsPercentIndex[ihisto] ) {
+       case AliMUONQAIndices::kTriggerErrorSummaryNorm:
+       case AliMUONQAIndices::kTriggerCalibSummaryNorm:
+       case AliMUONQAIndices::kTriggerReadOutErrorsNorm:
+         messages.Add(new TObjString("Values within limits"));
+         break;
        }
-       else text->SetFillColor(kGreen);
-       currHisto->GetListOfFunctions()->Add(text);
-       currHisto->SetStats(kFALSE);
-       currHisto->GetYaxis()->SetRangeUser(0., 110.);
       }
+      if ( MarkHisto(*currHisto, currRv) < rv[specie] )
+       rv[specie] = currRv;
+      currHisto->GetYaxis()->SetRangeUser(0., 110.);
+      SetupHisto(nAnalyzedEvents, messages, *currHisto, currRv, specie);
     } // loop on histos
   } // loop on species
 
@@ -151,3 +180,71 @@ AliMUONTriggerQAChecker::CheckESD(TObjArray** , const AliMUONRecoParam* )
   /// Check esd
   return 0x0;
 }
+
+
+//___________________________________________________________________ 
+void AliMUONTriggerQAChecker::SetupHisto(Int_t nevents, const TObjArray& messages, TH1& histo, AliMUONVQAChecker::ECheckCode code, Int_t esIndex)
+{
+  //
+  /// Add text to histos
+  //
+
+  Double_t y1 = 0.87 - (messages.GetLast()+2)*0.075;
+  TPaveText* text = new TPaveText(0.25,y1,0.75,0.89,"NDC");
+  
+  Int_t eventLimit = ( AliRecoParam::ConvertIndex(esIndex) == AliRecoParam::kCalib ) ? 5 : 20;
+
+  text->AddText(Form("MTR - Specie: %s", AliRecoParam::GetEventSpecieName(esIndex)));
+  text->AddText(Form("Total events %i", nevents));
+
+  TString defaultText = "";  
+  Int_t color = 0;
+  
+  if ( nevents == 0 ) {
+    color = AliMUONVQAChecker::kFatalColor;
+    defaultText = "No events analyzed!";
+  }
+  else if ( nevents <= eventLimit ) {
+    color = AliMUONVQAChecker::kWarningColor;
+    text->AddText("Not enough events to judge");
+    defaultText = "Please wait for more statistics";
+  }
+  else {
+    TIter next(&messages);
+    TObjString* str;
+    
+    while ( ( str = static_cast<TObjString*>(next()) ) ){
+      text->AddText(str->String());
+    }
+    
+    switch ( code ) {
+      case AliMUONVQAChecker::kInfo:
+        color = AliMUONVQAChecker::kInfoColor;
+        defaultText = "All is fine!";
+        break;
+      case AliMUONVQAChecker::kWarning:
+        color = AliMUONVQAChecker::kWarningColor;
+        defaultText = "Please keep an eye on it!";
+        break;
+      case AliMUONVQAChecker::kFatal:
+        color = AliMUONVQAChecker::kFatalColor;
+        defaultText = "PLEASE CALL MUON TRIGGER EXPERT!!!";
+        break;
+      default:
+        color = AliMUONVQAChecker::kErrorColor;
+        defaultText = "PLEASE CALL MUON TRIGGER EXPERT!";
+        break;
+    }
+  }
+
+  text->AddText(defaultText.Data());
+  text->SetFillColor(color);
+                      
+  histo.SetFillStyle(1001);
+  histo.SetFillColor(color);
+
+  histo.SetStats(kFALSE);
+    
+  histo.GetListOfFunctions()->Delete();
+  histo.GetListOfFunctions()->Add(text);
+}