DQMHistAnalysisHLTModule.cc

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#include <dqm/analysis/modules/DQMHistAnalysisHLTModule.h>
#include <framework/core/ModuleParam.templateDetails.h>
#include <TROOT.h>
 
#include <hlt/utilities/Units.h>
 
using namespace std;
using namespace Belle2;
 
namespace {
  bool hasValue(const std::string& name, TH1* histogram)
  {
    return histogram->GetXaxis()->FindFixBin(name.c_str()) != -1;
  }
 
  double getValue(const std::string& name, TH1* histogram)
  {
    if (not hasValue(name, histogram)) {
      B2ERROR("This histogram does not have this value! (fallback value = -1)"
              << LogVar("histogram", histogram->GetName())
              << LogVar("value", name));
      return -1;
    }
    auto binNumber = histogram->GetXaxis()->FindFixBin(name.c_str());
    return histogram->GetBinContent(binNumber);
  }
}
 
REG_MODULE(DQMHistAnalysisHLT);
 
DQMHistAnalysisHLTModule::DQMHistAnalysisHLTModule()
{
  setDescription("Modify and analyze the data quality histograms of HLT");
  addParam("bhabhaName", m_bhabhaName, "Name of the bhabha trigger to do a ratio against", m_bhabhaName);
  addParam("columnMapping", m_columnMapping, "Which columns to use for calculating ratios and cross sections", m_columnMapping);
  addParam("l1Histograms", m_l1Histograms, "Which l1 histograms to show", m_l1Histograms);
  addParam("retentionPerUnit", m_retentionPerUnit, "Which HLT filter lines to use for calculation retention rate per unit",
           m_retentionPerUnit);
}
 
void DQMHistAnalysisHLTModule::initialize()
{
  // this seems to be important, or strange things happen
  gROOT->cd();
 
  m_hEfficiency = {
    new TCanvas("HLT/Ratio"),
    new TH1F("Ratio", "Retention of selected HLT skims", 1, 0, 0)
  };
  m_hEfficiencyTotal = {
    new TCanvas("HLT/RatioTotal"),
    new TH1F("RatioTotal", "Ratio of Tags to all events", 1, 0, 0)
  };
  m_hCrossSection = {
    new TCanvas("HLT/CrossSection"),
    new TH1F("CrossSection", "Cross Section of triggered Events", 1, 0, 0)
  };
  m_hRatios = {
    new TCanvas("HLT/RatioToBahbha"),
    new TH1F("RatioToBahbha", "Ratio to bhabha events", 1, 0, 0)
  };
 
  for (const std::string& l1Name : m_l1Histograms) {
    m_hl1Ratios.emplace(l1Name, std::make_pair(
                          new TCanvas(("HLT/" + l1Name + "RatioToL1").c_str()),
                          // + 1 for total result
                          new TH1F((l1Name + "RatioToL1").c_str(), ("HLT Fractions for L1 " + l1Name).c_str(), 1, 0, 0)
                        ));
  }
 
  for (const std::string& filterLine : m_retentionPerUnit) {
    m_hRetentionPerUnit.emplace(filterLine, std::make_pair(
                                  new TCanvas(("HLT/" + filterLine + "_RetentionPerUnit").c_str()),
                                  new TH1F((filterLine + "_RetentionPerUnit").c_str(), ("Retention rate per unit of: " + filterLine).c_str(),
                                           HLTUnits::max_hlt_units + 1, 0,
                                           HLTUnits::max_hlt_units + 1)
                                ));
  }
 
  for (const auto& canvasAndHisto : {m_hEfficiencyTotal, m_hEfficiency, m_hCrossSection, m_hRatios}) {
    auto* histogram = canvasAndHisto.second;
    histogram->SetDirectory(0);
    histogram->SetOption("bar");
    histogram->SetFillStyle(0);
    histogram->SetMinimum(0);
    histogram->SetStats(false);
    histogram->Draw("hist");
  }
 
  for (const auto& nameAndcanvasAndHisto : m_hl1Ratios) {
    auto* histogram = nameAndcanvasAndHisto.second.second;
    histogram->SetDirectory(0);
    histogram->SetOption("bar");
    histogram->SetFillStyle(0);
    histogram->SetStats(false);
    histogram->Draw("hist");
  }
 
  for (const auto& nameAndcanvasAndHisto : m_hRetentionPerUnit) {
    auto* histogram = nameAndcanvasAndHisto.second.second;
    histogram->SetDirectory(0);
    histogram->SetOption("histe");
    histogram->SetMinimum(0);
    histogram->SetStats(false);
    histogram->Draw();
  }
 
  m_hMeanTime = {
    new TCanvas("HLT/MeanTime"),
    new TH1F("MeanTime", "Mean processing time", 1, 0, 0)
  };
 
  m_hErrorFlagFraction = {
    new TCanvas("HLT/ErrorFlagFraction"),
    new TH1D("ErrorFlagFraction", "Fraction of events with Error Flags", 1, 0, 0)
  };
 
  m_hFilteredFractionPerUnit = {
    new TCanvas("HLT/FilteredFractionPerUnit"),
    new TH1D("FilteredFractionPerUnit", "Fraction of events filtered per unit", 1, 0, 0)
  };
 
  m_hMeanBudgetTimePerUnit = {
    new TCanvas("HLT/MeanBudgetTimePerUnit"),
    new TH1F("MeanBudgetTimePerUnit", "Mean budget time per unit", 1, 0, 0)
  };
 
  m_hMeanProcessingTimePerUnit = {
    new TCanvas("HLT/MeanProcessingTimePerUnit"),
    new TH1F("MeanProcessingTimePerUnit", "Mean processing time per unit", 1, 0, 0)
  };
 
  m_hMeanMemory = {
    new TCanvas("HLT/MeanMemoryChange"),
    new TH1F("MeanMemoryChange", "Mean memory change [MB]", 1, 0, 0)
  };
 
  //EPICS PVs for HLT
  addDeltaPar("timing_statistics", "processingTimeHistogram", HistDelta::c_Events, 10000, 1);
  addDeltaPar("timing_statistics", "processesPerUnitHistogram", HistDelta::c_Events, 10000, 1);
  registerExternalEpicsPV("B2_nsm:get:ECL_LUM_MON:lum_det_run", "instLuminosity");
  registerExternalEpicsPV("B2_nsm:get:TTDS_COM:trigoutrate", "L1Rate");
  registerEpicsPV("HLT:ProcessingTime", "ProcessingTime");
  registerEpicsPV("HLT:BudgetTime", "BudgetTime");
  registerEpicsPV("HLT:CPUUsage", "CPUUsage");
 
}
 
 
void DQMHistAnalysisHLTModule::beginRun()
{
  for (const auto& canvasAndHisto : {m_hEfficiencyTotal, m_hEfficiency, m_hCrossSection, m_hRatios, m_hMeanTime, m_hMeanBudgetTimePerUnit, m_hMeanProcessingTimePerUnit, m_hMeanMemory}) {
    auto* canvas = canvasAndHisto.first;
    canvas->Clear();
  }
 
  for (const auto& canvasAndHisto : {m_hErrorFlagFraction, m_hFilteredFractionPerUnit}) {
    auto* canvas = canvasAndHisto.first;
    canvas->Clear();
  }
 
  for (const auto& nameAndcanvasAndHisto : m_hl1Ratios) {
    auto* canvas = nameAndcanvasAndHisto.second.first;
    canvas->Clear();
  }
 
  for (const auto& nameAndcanvasAndHisto : m_hRetentionPerUnit) {
    auto* canvas = nameAndcanvasAndHisto.second.first;
    canvas->Clear();
  }
 
  // Set alarm limits for HLT:CPUUsage epicsPV
  double unused = NAN;
  double m_meanUpperWarn = 0.9;
  double m_meanUpperAlarm = 1.0;
  requestLimitsFromEpicsPVs("CPUUsage", unused, unused, m_meanUpperWarn, m_meanUpperAlarm);
 
}
 
void DQMHistAnalysisHLTModule::event()
{
  auto* filterHistogram = findHist("softwaretrigger/filter");
  auto* skimHistogram = findHist("softwaretrigger/skim");
  auto* totalResultHistogram = findHist("softwaretrigger/total_result");
  auto* hltUnitNumberHistogram = findHist("softwaretrigger_before_filter/hlt_unit_number");
  auto* processesPerUnitHistogram = findHist("timing_statistics/processesPerUnitHistogram");
  auto* meanTimeHistogram = findHist("timing_statistics/meanTimeHistogram");
  auto* errorFlagHistogram = findHist("softwaretrigger_before_filter/error_flag");
  auto* hltUnitNumberHistogram_filtered = findHist("softwaretrigger/hlt_unit_number_after_filter");
  auto* fullTimeMeanPerUnitHistogram = findHist("timing_statistics/fullTimeMeanPerUnitHistogram");
  auto* processingTimeMeanPerUnitHistogram = findHist("timing_statistics/processingTimeMeanPerUnitHistogram");
  auto* meanMemoryHistogram = findHist("timing_statistics/meanMemoryHistogram");
 
  if (not filterHistogram) {
    B2ERROR("Can not find the filter histogram!");
    return;
  }
  if (not skimHistogram) {
    B2ERROR("Can not find the skim histogram!");
    return;
  }
  if (not totalResultHistogram) {
    B2ERROR("Can not find the total result histogram!");
    return;
  }
  if (not hltUnitNumberHistogram) {
    B2ERROR("Can not find the HLT unit number histogram!");
    return;
  }
  if (not processesPerUnitHistogram) {
    B2ERROR("Can not find the processes per unit histogram!");
    return;
  }
  if (not meanTimeHistogram) {
    B2ERROR("Can not find the mean processing time histogram!");
    return;
  }
  if (not errorFlagHistogram) {
    B2ERROR("Can not find the error flag histogram!");
    return;
  }
  if (not hltUnitNumberHistogram_filtered) {
    B2ERROR("Can not find the HLT unit number after filter histogram!");
    return;
  }
  if (not fullTimeMeanPerUnitHistogram) {
    B2ERROR("Can not find the HLT budget time per unit histogram!");
    return;
  }
  if (not processingTimeMeanPerUnitHistogram) {
    B2ERROR("Can not find the HLT processing time per unit histogram!");
    return;
  }
  if (not meanMemoryHistogram) {
    B2ERROR("Can not find the mean memory change histogram!");
    return;
  }
 
  // Set the epicsPVs for HLT
  auto hist_ProcessingTime = getDelta("timing_statistics", "processingTimeHistogram");
  double HLTProcessingTime = 0;
 
  if (hist_ProcessingTime) {
    HLTProcessingTime = hist_ProcessingTime->GetMean(); // unit = ms
    setEpicsPV("ProcessingTime", HLTProcessingTime);
  }
 
  auto hist_Procs = findHist("timing_statistics/processesPerUnitHistogram");
  double HLTBudgetTime = 0; // Number of HLT threads / L1 rate [kHz]
  double L1Rate = getEpicsPV("L1Rate");
 
  if (hist_Procs && L1Rate != 0) {
    double nProcs = hist_Procs->GetEntries() * 0.5; // Number of HLT threads
    HLTBudgetTime = nProcs * 1e03 / L1Rate; // unit = ms
    setEpicsPV("BudgetTime", HLTBudgetTime);
  }
 
  if (HLTBudgetTime != 0 and hist_ProcessingTime)
    setEpicsPV("CPUUsage", HLTProcessingTime / HLTBudgetTime);
 
 
  m_hEfficiencyTotal.second->Reset();
  m_hEfficiency.second->Reset();
  m_hCrossSection.second->Reset();
  m_hRatios.second->Reset();
 
  double instLuminosity = getEpicsPV("instLuminosity");
  double numberOfAcceptedHLTEvents = getValue("total_result", totalResultHistogram);
  double numberOfBhabhaEvents = getValue(m_bhabhaName, skimHistogram);
  double numberOfAllEvents = hltUnitNumberHistogram->GetEntries();
  double numberOfProcesses = processesPerUnitHistogram->GetEntries();
 
  m_hEfficiencyTotal.second->Fill("total_result", numberOfAcceptedHLTEvents / numberOfAllEvents);
  if (instLuminosity != 0) {
    m_hCrossSection.second->Fill("total_result", numberOfAcceptedHLTEvents / numberOfAllEvents * instLuminosity);
  }
  m_hRatios.second->Fill("total_result", numberOfAcceptedHLTEvents / numberOfBhabhaEvents);
 
  for (const auto& columnMapping : m_columnMapping) {
    const auto& from = columnMapping.first;
    const auto& to = columnMapping.second;
 
    double value = 0;
    if (hasValue(from, filterHistogram)) {
      value = getValue(from, filterHistogram);
    } else if (hasValue(from, skimHistogram)) {
      value = getValue(from, skimHistogram);
    } else {
      B2ERROR("Can not find value " << from << ". Will not use it!");
      continue;
    }
 
    m_hEfficiency.second->Fill(to.c_str(), value / numberOfAcceptedHLTEvents);
    m_hEfficiencyTotal.second->Fill(to.c_str(), value / numberOfAllEvents);
    if (instLuminosity != 0) {
      m_hCrossSection.second->Fill(to.c_str(), value / numberOfAllEvents * instLuminosity);
    }
    m_hRatios.second->Fill(to.c_str(), value / numberOfBhabhaEvents);
  }
 
  for (const std::string& l1Name : m_l1Histograms) {
    auto* histogram = m_hl1Ratios.at(l1Name).second;
    histogram->Reset();
 
    auto* l1Histogram = findHist("softwaretrigger/" + l1Name);
    auto* l1TotalResultHistogram = findHist("softwaretrigger/l1_total_result");
 
    if (not l1Histogram or not l1TotalResultHistogram) {
      B2ERROR("Can not find L1 histograms from softwaretrigger!");
      continue;
    }
 
    for (const auto& columnMapping : m_columnMapping) {
      const auto& from = columnMapping.first;
      const auto& to = columnMapping.second;
 
      if (not hasValue(from, l1Histogram)) {
        B2ERROR("Can not find label " << from << " in l1 histogram " << l1Name);
        continue;
      }
 
      if (not hasValue(l1Name, l1TotalResultHistogram)) {
        B2ERROR("Can not find label " << l1Name << " in l1 total result histogram");
        continue;
      }
 
      const double hltValueInL1Bin = getValue(from, l1Histogram);
      const double l1TotalResult = getValue(l1Name, l1TotalResultHistogram);
 
      histogram->Fill(to.c_str(), hltValueInL1Bin / l1TotalResult);
    }
 
    // and add a total result bin
    const auto from = "hlt_result";
    const auto to = "hlt_result";
 
    if (not hasValue(from, l1Histogram)) {
      B2ERROR("Can not find label " << from << " in l1 histogram " << l1Name);
      continue;
    }
 
    if (not hasValue(l1Name, l1TotalResultHistogram)) {
      B2ERROR("Can not find label " << l1Name << " in l1 total result histogram");
      continue;
    }
 
    const double hltValueInL1Bin = getValue(from, l1Histogram);
    const double l1TotalResult = getValue(l1Name, l1TotalResultHistogram);
 
    histogram->Fill(to, hltValueInL1Bin / l1TotalResult);
  }
 
  for (const std::string& filterLine : m_retentionPerUnit) {
    auto* histogram = m_hRetentionPerUnit.at(filterLine).second;
    histogram->Reset();
 
    auto* filterLineHistogram = findHist("softwaretrigger/" + filterLine + "_per_unit");
 
    if (not filterLineHistogram) {
      B2ERROR("Can not find " << filterLineHistogram << "_per_event histograms from softwaretrigger!");
      continue;
    }
 
    for (unsigned int i = 1; i <= HLTUnits::max_hlt_units + 1; i++) {
      double totalUnitValue = hltUnitNumberHistogram->GetBinContent(i);
      if (totalUnitValue == 0) {
        histogram->Fill(i, 0);
      } else {
        double filterLineUnitValue = filterLineHistogram->GetBinContent(i);
        histogram->SetBinContent(i, filterLineUnitValue / totalUnitValue);
      }
    }
  }
 
  if (m_hMeanTime.second) delete m_hMeanTime.second;
  m_hMeanTime.second = dynamic_cast<TH1*>(meanTimeHistogram->Clone("MeanTime"));
  m_hMeanTime.second->Scale(1 / numberOfProcesses);
 
  if (m_hMeanMemory.second) delete m_hMeanMemory.second;
  m_hMeanMemory.second = dynamic_cast<TH1*>(meanMemoryHistogram->Clone("MeanMemoryChange"));
  m_hMeanMemory.second->Scale(1 / numberOfProcesses);
 
  if (m_hErrorFlagFraction.second) delete m_hErrorFlagFraction.second;
  m_hErrorFlagFraction.second = dynamic_cast<TH1*>(errorFlagHistogram->Clone("ErrorFlagFraction"));
  m_hErrorFlagFraction.second->Scale(1 / numberOfAllEvents);
  m_hErrorFlagFraction.second->SetTitle("Fraction of events with error flags");
 
  if (m_hFilteredFractionPerUnit.second) delete m_hFilteredFractionPerUnit.second;
  m_hFilteredFractionPerUnit.second = dynamic_cast<TH1*>(hltUnitNumberHistogram_filtered->Clone("FilteredFractionPerUnit"));
  m_hFilteredFractionPerUnit.second->Divide(hltUnitNumberHistogram_filtered, hltUnitNumberHistogram);
  m_hFilteredFractionPerUnit.second->SetTitle("Fraction of events filtered per unit");
 
  if (m_hMeanBudgetTimePerUnit.second) delete m_hMeanBudgetTimePerUnit.second;
  m_hMeanBudgetTimePerUnit.second = dynamic_cast<TH1*>(fullTimeMeanPerUnitHistogram->Clone("MeanBudgetTimePerUnit"));
  m_hMeanBudgetTimePerUnit.second->Divide(fullTimeMeanPerUnitHistogram, processesPerUnitHistogram);
 
  if (m_hMeanProcessingTimePerUnit.second) delete m_hMeanProcessingTimePerUnit.second;
  m_hMeanProcessingTimePerUnit.second = dynamic_cast<TH1*>(processingTimeMeanPerUnitHistogram->Clone("MeanProcessingTimePerUnit"));
  m_hMeanProcessingTimePerUnit.second->Divide(processingTimeMeanPerUnitHistogram, processesPerUnitHistogram);
 
  for (const auto& canvasAndHisto : {m_hEfficiencyTotal, m_hEfficiency, m_hCrossSection, m_hRatios, m_hMeanTime, m_hMeanBudgetTimePerUnit, m_hMeanProcessingTimePerUnit, m_hMeanMemory}) {
    auto* canvas = canvasAndHisto.first;
    auto* histogram = canvasAndHisto.second;
 
    canvas->cd();
    histogram->LabelsDeflate("X");
    histogram->Draw("hist");
    canvas->Modified();
    canvas->Update();
  }
 
  for (const auto& canvasAndHisto : {m_hErrorFlagFraction, m_hFilteredFractionPerUnit}) {
    auto* canvas = canvasAndHisto.first;
    auto* histogram = canvasAndHisto.second;
 
    canvas->cd();
    histogram->LabelsDeflate("X");
    histogram->Draw("hist");
    histogram->SetStats(false);
    canvas->Modified();
    canvas->Update();
  }
 
  for (const auto& nameAndCanvasAndHisto : m_hl1Ratios) {
    auto* canvas = nameAndCanvasAndHisto.second.first;
    auto* histogram = nameAndCanvasAndHisto.second.second;
 
    canvas->cd();
    histogram->LabelsDeflate("X");
    histogram->Draw("hist");
    canvas->Modified();
    canvas->Update();
  }
 
  for (const auto& nameAndCanvasAndHisto : m_hRetentionPerUnit) {
    auto* canvas = nameAndCanvasAndHisto.second.first;
    auto* histogram = nameAndCanvasAndHisto.second.second;
 
    canvas->cd();
    histogram->Draw("hist");
    canvas->Modified();
    canvas->Update();
  }
}
 
void DQMHistAnalysisHLTModule::terminate()
{
}