SummaryOutputProducer Class Reference

Classes
struct	Event
struct	GenericSummary
struct	Pair
struct	TriggerSummary

Public Member Functions
	SummaryOutputProducer (const JsonOutputProducer &_json, bool _storeROOT, bool _storeCSV)
void	write ()

Public Attributes
bool	storeCSV
bool	storeROOT

Private Member Functions
void	prepareSummaries (const int _run, const std::vector< JsonOutputProducer::JsonEvent > &_events)
bool	writeCSV_module (std::string &file_name) const
bool	writeCSV_trigger (std::string &file_name) const
bool	writeHistograms (std::string &file_name) const

Private Attributes
const JsonOutputProducer &	json
std::map< int, GenericSummary >	m_moduleSummary
std::map< int, TriggerSummary >	m_triggerSummary
int	run

Detailed Description

Definition at line 808 of file hltDiff.cc.

Constructor & Destructor Documentation

SummaryOutputProducer()

SummaryOutputProducer::SummaryOutputProducer ( const JsonOutputProducer &  _json, bool  _storeROOT, bool  _storeCSV  )

inline

Definition at line 1168 of file hltDiff.cc.

      : json(_json), run(0), storeROOT(_storeROOT), storeCSV(_storeCSV) {}

Member Function Documentation

prepareSummaries()

void SummaryOutputProducer::prepareSummaries ( const int  _run, const std::vector< JsonOutputProducer::JsonEvent > &  _events  )

inlineprivate

Definition at line 934 of file hltDiff.cc.

                                                                                               {
    this->run = _run;
    // Initialising the summary objects for trigger/module
    m_triggerSummary.clear();
    m_moduleSummary.clear();
    const size_t nTriggers(json.vars.trigger.size());
    const size_t nModules(json.vars.label.size());
    for (size_t i = 0; i < nTriggers; ++i)
      m_triggerSummary.emplace(i, TriggerSummary(i, json));
    for (size_t i = 0; i < nModules; ++i)
      m_moduleSummary.emplace(i, GenericSummary(i, json, json.vars.label));
 
    // Add each affected trigger in each event to the trigger/module summary objects
    for (const JsonOutputProducer::JsonEvent& event : _events) {
      for (size_t iTrigger = 0; iTrigger < event.triggerStates.size(); ++iTrigger) {
        const JsonOutputProducer::JsonTriggerEventState& state = event.triggerStates.at(iTrigger);
        m_triggerSummary.at(state.tr).addEntry(event, iTrigger, json.vars.label);
        const int moduleId = state.o.s == State::Fail ? state.o.l : state.n.l;
        m_moduleSummary.at(moduleId).addEntry(event, iTrigger);
      }
    }
  }

References Fail, mps_fire::i, and gpuClustering::moduleId.

write()

void SummaryOutputProducer::write ( )

inline

Definition at line 1171 of file hltDiff.cc.

               {
    std::vector<std::string> filesCreated, filesNotCreated;
    // Processing every run from the JSON producer
    if (!json.m_run_events.empty()) {
      for (const auto& runEvents : json.m_run_events) {
        prepareSummaries(runEvents.first, runEvents.second);
        if (storeROOT) {
          std::string fName;
          auto& fNameVec = writeHistograms(fName) ? filesCreated : filesNotCreated;
          fNameVec.push_back(fName);
        }
        if (storeCSV) {
          std::string fNameTrigger;
          auto& fNameTriggerVec = writeCSV_trigger(fNameTrigger) ? filesCreated : filesNotCreated;
          fNameTriggerVec.push_back(fNameTrigger);
 
          std::string fNameModule;
          auto& fNameModuleVec = writeCSV_module(fNameModule) ? filesCreated : filesNotCreated;
          fNameModuleVec.push_back(fNameModule);
        }
      }
    } else {
      if (storeROOT) {
        std::string fName;
        auto& fNameVec = writeHistograms(fName) ? filesCreated : filesNotCreated;
        fNameVec.push_back(fName);
      }
      if (storeCSV) {
        std::string fNameTrigger;
        auto& fNameTriggerVec = writeCSV_trigger(fNameTrigger) ? filesCreated : filesNotCreated;
        fNameTriggerVec.push_back(fNameTrigger);
 
        std::string fNameModule;
        auto& fNameModuleVec = writeCSV_module(fNameModule) ? filesCreated : filesNotCreated;
        fNameModuleVec.push_back(fNameModule);
      }
    }
 
    if (!filesCreated.empty()) {
      std::cout << "Created the following summary files:" << std::endl;
      for (const std::string& filename : filesCreated)
        std::cout << " " << filename << std::endl;
    }
 
    if (!filesNotCreated.empty()) {
      std::cout << "Failed to create the following summary files (check output directory and its permissions):"
                << std::endl;
      for (const std::string& filename : filesNotCreated)
        std::cout << " " << filename << std::endl;
    }
  }

References gather_cfg::cout, corrVsCorr::filename, MainPageGenerator::fName, hltMonBTagIPClient_cfi::storeROOT, and AlCaHLTBitMon_QueryRunRegistry::string.

writeCSV_module()

bool SummaryOutputProducer::writeCSV_module ( std::string &  file_name ) const

inlineprivate

Definition at line 1139 of file hltDiff.cc.

                                                   {
    bool ret = false;
 
    file_name = json.output_filename_base(this->run) += "_module.csv";
    FILE* out_file = fopen(file_name.c_str(), "w");
 
    if (out_file) {
      fprintf(out_file, "Total,Gained,Lost,Changed,module\n");
      for (const auto& idSummary : m_moduleSummary) {
        const SummaryOutputProducer::GenericSummary& S = idSummary.second;
        fprintf(out_file,
                "%d,+%.f,-%.f,~%.f,%s\n",
                this->json.configuration.events,
                S.gained().v,
                S.lost().v,
                S.changed().v,
                S.name.c_str());
      }
      fclose(out_file);
      ret = true;
    }
 
    return ret;
  }

References JsonOutputProducer::configuration, JsonOutputProducer::JsonConfiguration::events, contentValuesCheck::file_name, DeadROCCounter::out_file, and runTheMatrix::ret.

writeCSV_trigger()

bool SummaryOutputProducer::writeCSV_trigger ( std::string &  file_name ) const

inlineprivate

Definition at line 1106 of file hltDiff.cc.

                                                    {
    bool ret = false;
 
    file_name = json.output_filename_base(this->run) += "_trigger.csv";
    FILE* out_file = fopen(file_name.c_str(), "w");
 
    if (out_file) {
      fprintf(out_file,
              "Total,Accepted OLD,Accepted NEW,Gained,Lost,|G|/A_N + "
              "|L|/AO,sigma(AN)+sigma(AO),Changed,C/(T-AO),sigma(T-AO),trigger\n");
      for (const auto& idSummary : m_triggerSummary) {
        const SummaryOutputProducer::TriggerSummary& S = idSummary.second;
        fprintf(out_file,
                "%d,%d,%d,%+.f,%+.f,%.2f%%,%.2f%%,~%.f,~%.2f%%,%.2f%%,%s\n",
                this->json.configuration.events,
                S.accepted_o,
                S.accepted_n,
                S.gained().v,
                -1.0 * S.lost().v,
                (S.gained(1).v + S.lost(1).v) * 100.0,
                (S.gained(1).e + S.lost(1).e) * 100.0,
                S.changed().v,
                S.changed(1).v * 100.0,
                S.changed(1).e * 100.0,
                S.name.c_str());
      }
      fclose(out_file);
      ret = true;
    }
 
    return ret;
  }

References JsonOutputProducer::configuration, JsonOutputProducer::JsonConfiguration::events, contentValuesCheck::file_name, DeadROCCounter::out_file, and runTheMatrix::ret.

writeHistograms()

bool SummaryOutputProducer::writeHistograms ( std::string &  file_name ) const

inlineprivate

Definition at line 957 of file hltDiff.cc.

                                                   {
    // Storing histograms to a ROOT file
    file_name = json.output_filename_base(this->run) += ".root";
    auto out_file = new TFile(file_name.c_str(), "RECREATE");
    if (not out_file or out_file->IsZombie()) {
      out_file->Close();
      return false;
    }
 
    std::map<std::string, TH1*> m_histo;
    // Counting the numbers of bins for different types of histograms
    // *_c - changed; *_gl - gained or lost
    int nTriggers(0), nTriggers_c(0), nTriggers_gl(0), nModules_c(0), nModules_gl(0);
 
    for (const auto& idSummary : m_triggerSummary) {
      if (idSummary.second.accepted_o > 0)
        ++nTriggers;
      if (idSummary.second.keepForGL())
        ++nTriggers_gl;
      if (idSummary.second.keepForC())
        ++nTriggers_c;
    }
    for (const auto& idSummary : m_moduleSummary) {
      if (idSummary.second.keepForGL())
        ++nModules_gl;
      if (idSummary.second.keepForC())
        ++nModules_c;
    }
    // Manually increasing N bins to have histograms with meaningful axis ranges
    nTriggers = std::max(1, nTriggers);
    nTriggers_gl = std::max(1, nTriggers_gl);
    nTriggers_c = std::max(1, nTriggers_c);
    nModules_c = std::max(1, nModules_c);
    nModules_gl = std::max(1, nModules_gl);
 
    // Initialising overview histograms
    std::string name = "trigger_accepted";
    m_histo.emplace(name, new TH1F(name.c_str(), ";;Events accepted^{OLD}", nTriggers, 0, nTriggers));
    name = "trigger_gained";
    m_histo.emplace(name, new TH1F(name.c_str(), ";;Events gained", nTriggers_gl, 0, nTriggers_gl));
    name = "trigger_lost";
    m_histo.emplace(name, new TH1F(name.c_str(), ";;Events lost", nTriggers_gl, 0, nTriggers_gl));
    name = "trigger_changed";
    m_histo.emplace(name, new TH1F(name.c_str(), ";;Events changed", nTriggers_c, 0, nTriggers_c));
    name = "trigger_gained_frac";
    m_histo.emplace(name, new TH1F(name.c_str(), ";;#frac{gained}{accepted}", nTriggers_gl, 0, nTriggers_gl));
    name = "trigger_lost_frac";
    m_histo.emplace(name, new TH1F(name.c_str(), ";;#frac{lost}{accepted}", nTriggers_gl, 0, nTriggers_gl));
    name = "trigger_changed_frac";
    m_histo.emplace(name, new TH1F(name.c_str(), ";;#frac{changed}{all - accepted}", nTriggers_c, 0, nTriggers_c));
    name = "module_changed";
    m_histo.emplace(name, new TH1F(name.c_str(), ";;Events changed", nModules_c, 0, nModules_c));
    name = "module_gained";
    m_histo.emplace(name, new TH1F(name.c_str(), ";;Events gained", nModules_gl, 0, nModules_gl));
    name = "module_lost";
    m_histo.emplace(name, new TH1F(name.c_str(), ";;Events lost", nModules_gl, 0, nModules_gl));
 
    // Filling the per-trigger bins in the summary histograms
    size_t bin(0), bin_c(0), bin_gl(0);
    for (const auto& idSummary : m_triggerSummary) {
      const TriggerSummary& summary = idSummary.second;
      if (summary.accepted_o > 0) {
        ++bin;
        // Setting bin contents
        m_histo.at("trigger_accepted")->SetBinContent(bin, summary.accepted_o);
        // Setting bin labels
        m_histo.at("trigger_accepted")->GetXaxis()->SetBinLabel(bin, summary.name.c_str());
      }
      if (summary.keepForGL()) {
        ++bin_gl;
        // Setting bin contents
        m_histo.at("trigger_gained")->SetBinContent(bin_gl, summary.gained().v);
        m_histo.at("trigger_lost")->SetBinContent(bin_gl, -summary.lost().v);
        m_histo.at("trigger_gained_frac")->SetBinContent(bin_gl, summary.gained(1).v);
        m_histo.at("trigger_lost_frac")->SetBinContent(bin_gl, -summary.lost(1).v);
        // Setting bin errors
        m_histo.at("trigger_gained_frac")->SetBinError(bin_gl, summary.gained(1).e);
        m_histo.at("trigger_lost_frac")->SetBinError(bin_gl, -summary.lost(1).e);
        // Setting bin labels
        m_histo.at("trigger_gained")->GetXaxis()->SetBinLabel(bin_gl, summary.name.c_str());
        m_histo.at("trigger_lost")->GetXaxis()->SetBinLabel(bin_gl, summary.name.c_str());
        m_histo.at("trigger_gained_frac")->GetXaxis()->SetBinLabel(bin_gl, summary.name.c_str());
        m_histo.at("trigger_lost_frac")->GetXaxis()->SetBinLabel(bin_gl, summary.name.c_str());
      }
      if (summary.keepForC()) {
        ++bin_c;
        // Setting bin contents
        m_histo.at("trigger_changed")->SetBinContent(bin_c, summary.changed().v);
        m_histo.at("trigger_changed_frac")->SetBinContent(bin_c, summary.changed(1).v);
        // Setting bin errors
        m_histo.at("trigger_changed_frac")->SetBinError(bin_c, summary.changed(1).e);
        // Setting bin labels
        m_histo.at("trigger_changed")->GetXaxis()->SetBinLabel(bin_c, summary.name.c_str());
        m_histo.at("trigger_changed_frac")->GetXaxis()->SetBinLabel(bin_c, summary.name.c_str());
      }
    }
 
    // Filling the per-module bins in the summary histograms
    bin = 0;
    bin_c = 0;
    bin_gl = 0;
    for (const auto& idSummary : m_moduleSummary) {
      ++bin;
      const GenericSummary& summary = idSummary.second;
      if (summary.keepForGL()) {
        ++bin_gl;
        // Setting bin contents
        m_histo.at("module_gained")->SetBinContent(bin_gl, summary.gained().v);
        m_histo.at("module_lost")->SetBinContent(bin_gl, -summary.lost().v);
        // Setting bin labels
        m_histo.at("module_gained")->GetXaxis()->SetBinLabel(bin_gl, summary.name.c_str());
        m_histo.at("module_lost")->GetXaxis()->SetBinLabel(bin_gl, summary.name.c_str());
      }
      if (summary.keepForC()) {
        ++bin_c;
        // Setting bin contents
        m_histo.at("module_changed")->SetBinContent(bin_c, summary.changed().v);
        // Setting bin labels
        m_histo.at("module_changed")->GetXaxis()->SetBinLabel(bin_c, summary.name.c_str());
      }
    }
 
    // Styling the histograms
    for (const auto& nameHisto : m_histo) {
      const std::string name = nameHisto.first;
      TH1* histo = nameHisto.second;
      if (name.find("gained") != std::string::npos || name.find("changed") != std::string::npos) {
        if (name.find("frac") != std::string::npos)
          histo->GetYaxis()->SetRangeUser(0.0, 1.0);
      }
      if (name.find("lost") != std::string::npos) {
        if (name.find("frac") != std::string::npos)
          histo->GetYaxis()->SetRangeUser(-1.0, 0.0);
      }
    }
 
    // Storing the histograms in a proper folder according to the DQM convention
    char savePath[1000];
    sprintf(savePath, "DQMData/Run %d/HLT/Run summary/EventByEvent/", this->run);
    out_file->mkdir(savePath);
    gDirectory->cd(savePath);
    gDirectory->Write();
    for (const auto& nameHisto : m_histo)
      nameHisto.second->Write(nameHisto.first.c_str());
    out_file->Close();
 
    return true;
  }

References newFWLiteAna::bin, contentValuesCheck::file_name, timingPdfMaker::histo, SiStripPI::max, Skims_PA_cff::name, or, DeadROCCounter::out_file, AlCaHLTBitMon_QueryRunRegistry::string, and edmLumisInFiles::summary.

Member Data Documentation

json

const JsonOutputProducer& SummaryOutputProducer::json

private

Definition at line 810 of file hltDiff.cc.

m_moduleSummary

std::map<int, GenericSummary> SummaryOutputProducer::m_moduleSummary

private

Definition at line 932 of file hltDiff.cc.

m_triggerSummary

std::map<int, TriggerSummary> SummaryOutputProducer::m_triggerSummary

private

Definition at line 931 of file hltDiff.cc.

run

int SummaryOutputProducer::run

private

Definition at line 811 of file hltDiff.cc.

Referenced by DTWorkflow.DTWorkflow::all(), Types.EventID::cppID(), Types.LuminosityBlockID::cppID(), o2olib.O2OTool::execute(), and dqm_interfaces.DirWalkerFile::walk().

storeCSV

bool SummaryOutputProducer::storeCSV

Definition at line 1166 of file hltDiff.cc.

storeROOT

bool SummaryOutputProducer::storeROOT

Definition at line 1165 of file hltDiff.cc.