SiStripActionExecutor.cc

Go to the documentation of this file.

#include "DQM/SiStripMonitorClient/interface/SiStripActionExecutor.h"
#include "DQMServices/Core/interface/DQMStore.h"

#include "CalibFormats/SiStripObjects/interface/SiStripDetCabling.h"
#include "CalibTracker/SiStripCommon/interface/SiStripDetInfoFileReader.h"

#include "DataFormats/SiStripDetId/interface/StripSubdetector.h"

#include "DQM/SiStripCommon/interface/SiStripFolderOrganizer.h"
#include "DQM/SiStripMonitorClient/interface/SiStripUtility.h"
#include "DQM/SiStripMonitorClient/interface/SiStripLayoutParser.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include <fstream>
#include <iomanip>
#include <iostream>
#include <sstream>

SiStripActionExecutor::SiStripActionExecutor(edm::ParameterSet const& ps)
  : pSet_{ps}
{
  edm::LogInfo("SiStripActionExecutor") << " Creating SiStripActionExecutor "
                                        << "\n";
}

SiStripActionExecutor::~SiStripActionExecutor()
{
  edm::LogInfo("SiStripActionExecutor") << " Deleting SiStripActionExecutor "
                                        << "\n";
}

bool
SiStripActionExecutor::readConfiguration()
{
  if (!summaryCreator_) {
    summaryCreator_ = std::make_unique<SiStripSummaryCreator>();
  }
  auto const fpath = pSet_.getUntrackedParameter<std::string>(
    "SummaryConfigPath",
    "DQM/SiStripMonitorClient/data/sistrip_monitorelement_config.xml");
  return summaryCreator_->readConfiguration(fpath);
}

//
// -- Read Configuration File
//
bool
SiStripActionExecutor::readTkMapConfiguration(edm::EventSetup const& eSetup)
{
  tkMapCreator_ = std::make_unique<SiStripTrackerMapCreator>(eSetup);
  return tkMapCreator_.get() != nullptr;
}
//
// -- Create and Fill Summary Monitor Elements
//
void
SiStripActionExecutor::createSummary(DQMStore& dqm_store)
{
  if (!summaryCreator_) return;

  dqm_store.cd();
  std::string dname = "SiStrip/MechanicalView";
  if (dqm_store.dirExists(dname)) {
    dqm_store.cd(dname);
    summaryCreator_->createSummary(dqm_store);
  }
}
//
// -- Create and Fill Summary Monitor Elements
//
void
SiStripActionExecutor::createSummaryOffline(DQMStore& dqm_store)
{
  if (!summaryCreator_) return;

  dqm_store.cd();
  std::string dname = "MechanicalView";
  if (SiStripUtility::goToDir(dqm_store, dname)) {
    summaryCreator_->createSummary(dqm_store);
  }
  dqm_store.cd();
}
//
// -- create tracker map
//
void
SiStripActionExecutor::createTkMap(edm::ParameterSet const& tkmapPset,
                                   DQMStore& dqm_store,
                                   std::string& map_type,
                                   edm::EventSetup const& eSetup)
{
  if (tkMapCreator_) tkMapCreator_->create(tkmapPset, dqm_store, map_type, eSetup);
}
//
// -- create tracker map for offline
//
void
SiStripActionExecutor::createOfflineTkMap(edm::ParameterSet const& tkmapPset,
                                          DQMStore& dqm_store,
                                          std::string& map_type,
                                          edm::EventSetup const& eSetup)
{
  if (tkMapCreator_) tkMapCreator_->createForOffline(tkmapPset, dqm_store, map_type, eSetup);
}
//
// -- create root file with detId info from tracker maps
//
void
SiStripActionExecutor::createTkInfoFile(std::vector<std::string> map_names,
                                        TTree* tkinfo_tree,
                                        DQMStore& dqm_store)
{
  if (!tkMapCreator_) return;

  auto const& detidList = edm::Service<SiStripDetInfoFileReader> {}
  ->getAllDetIds();
  tkMapCreator_->createInfoFile(map_names, tkinfo_tree, dqm_store, detidList);
}
//
// -- Create Status Monitor Elements
//
void
SiStripActionExecutor::createStatus(DQMStore& dqm_store)
{
  if (qualityChecker_.get() == nullptr) {
    qualityChecker_ = std::make_unique<SiStripQualityChecker>(pSet_);
  }
  qualityChecker_->bookStatus(dqm_store);
}

void
SiStripActionExecutor::fillDummyStatus()
{
  qualityChecker_->fillDummyStatus();
}

void
SiStripActionExecutor::fillStatus(
  DQMStore& dqm_store,
  edm::ESHandle<SiStripDetCabling> const& detcabling,
  edm::EventSetup const& eSetup)
{
  qualityChecker_->fillStatus(dqm_store, detcabling, eSetup);
}

void
SiStripActionExecutor::fillStatusAtLumi(DQMStore& dqm_store)
{
  qualityChecker_->fillStatusAtLumi(dqm_store);
}

void
SiStripActionExecutor::createDummyShiftReport()
{
  std::ofstream report_file;
  report_file.open("sistrip_shift_report.txt", std::ios::out);
  report_file << " Nothing to report!!" << std::endl;
  report_file.close();
}

void
SiStripActionExecutor::createShiftReport(DQMStore& dqm_store)
{
  // Read layout configuration
  std::string const localPath{
    "DQM/SiStripMonitorClient/data/sistrip_plot_layout.xml"};
  SiStripLayoutParser layout_parser;
  layout_parser.getDocument(edm::FileInPath(localPath).fullPath());

  std::map<std::string, std::vector<std::string>> layout_map;
  if (!layout_parser.getAllLayouts(layout_map)) return;

  std::ostringstream shift_summary;
  configWriter_ = std::make_unique<SiStripConfigWriter>();
  configWriter_->init("ShiftReport");

  // Print Report Summary Content
  shift_summary << " Report Summary Content :\n"
                << " =========================" << std::endl;
  configWriter_->createElement("ReportSummary");

  MonitorElement* me{nullptr};
  std::string report_path;
  report_path = "SiStrip/EventInfo/reportSummaryContents/SiStrip_DetFraction_TECB";
  me = dqm_store.get(report_path);
  printReportSummary(me, shift_summary, "TECB");

  report_path = "SiStrip/EventInfo/reportSummaryContents/SiStrip_DetFraction_TECF";
  me = dqm_store.get(report_path);
  printReportSummary(me, shift_summary, "TECF");

  report_path = "SiStrip/EventInfo/reportSummaryContents/SiStrip_DetFraction_TIB";
  me = dqm_store.get(report_path);
  printReportSummary(me, shift_summary, "TIB");

  report_path = "SiStrip/EventInfo/reportSummaryContents/SiStrip_DetFraction_TIDB";
  me = dqm_store.get(report_path);
  printReportSummary(me, shift_summary, "TIDB");

  report_path = "SiStrip/EventInfo/reportSummaryContents/SiStrip_DetFraction_TIDF";
  me = dqm_store.get(report_path);
  printReportSummary(me, shift_summary, "TIDF");

  report_path = "SiStrip/EventInfo/reportSummaryContents/SiStrip_DetFraction_TOB";
  me = dqm_store.get(report_path);
  printReportSummary(me, shift_summary, "TOB");

  shift_summary << std::endl;
  printShiftHistoParameters(dqm_store, layout_map, shift_summary);

  std::ofstream report_file;
  report_file.open("sistrip_shift_report.txt", std::ios::out);
  report_file << shift_summary.str() << std::endl;
  report_file.close();
  configWriter_->write("sistrip_shift_report.xml");
  configWriter_.reset();
}

void
SiStripActionExecutor::printReportSummary(MonitorElement* me,
                                          std::ostringstream& str_val,
                                          std::string name)
{
  str_val <<" " << name << "  : ";
  std::string value;
  SiStripUtility::getMEValue(me, value);
  configWriter_->createChildElement("MonitorElement", name, "value", value);
  float fvalue = atof(value.c_str());
  if (fvalue == -1.0)
    str_val << " Dummy Value " << std::endl;
  else
    str_val << fvalue << std::endl;
}

void
SiStripActionExecutor::printShiftHistoParameters(
  DQMStore& dqm_store,
  std::map<std::string, std::vector<std::string>> const& layout_map,
  std::ostringstream& str_val)
{
  str_val << std::endl;
  for (auto const& [set_name, path_names] : layout_map) {
    if (set_name.find("Summary") != std::string::npos) continue;
    configWriter_->createElement(set_name);

    str_val << " " << set_name << " : " << std::endl;
    str_val << " ===================================="<< std::endl;

    str_val << std::setprecision(2);
    str_val << setiosflags(std::ios::fixed);
    for (auto const& path_name : path_names) {
      if (path_name.empty()) continue;
      MonitorElement* me = dqm_store.get(path_name);
      std::ostringstream entry_str, mean_str, rms_str;
      entry_str << std::setprecision(2);
      entry_str << setiosflags(std::ios::fixed);
      mean_str << std::setprecision(2);
      mean_str << setiosflags(std::ios::fixed);
      rms_str << std::setprecision(2);
      rms_str << setiosflags(std::ios::fixed);
      entry_str << std::setw(7) << me->getEntries();
      mean_str << std::setw(7) << me->getMean();
      rms_str << std::setw(7) << me->getRMS();
      configWriter_->createChildElement("MonitorElement",
                                        me->getName(),
                                        "entries",
                                        entry_str.str(),
                                        "mean",
                                        mean_str.str(),
                                        "rms",
                                        rms_str.str());

      if (me)
        str_val << " " << me->getName() << " : entries = " << std::setw(7)
                << me->getEntries() << " mean = " << me->getMean()
                << " : rms = " << me->getRMS() << '\n';
    }
    str_val << std::endl;
  }
}

//
//  -- Print List of Modules with QTest warning or Error
//
void
SiStripActionExecutor::printFaultyModuleList(DQMStore& dqm_store,
                                             std::ostringstream& str_val)
{
  dqm_store.cd();

  std::string mdir = "MechanicalView";
  if (!SiStripUtility::goToDir(dqm_store, mdir)) return;
  std::string mechanicalview_dir = dqm_store.pwd();

  std::vector<std::string> subdet_folder;
  subdet_folder.push_back("TIB");
  subdet_folder.push_back("TOB");
  subdet_folder.push_back("TEC/MINUS");
  subdet_folder.push_back("TEC/PLUS");
  subdet_folder.push_back("TID/MINUS");
  subdet_folder.push_back("TID/PLUS");

  int nDetsTotal = 0;
  int nDetsWithErrorTotal = 0;
  for (auto const& sd : subdet_folder) {
    std::string dname = mechanicalview_dir + "/" + sd;
    if (!dqm_store.dirExists(dname)) continue;
    str_val << "============\n" << sd << '\n' << "============\n" << std::endl;

    dqm_store.cd(dname);
    std::vector<std::string> module_folders;
    SiStripUtility::getModuleFolderList(dqm_store, module_folders);
    int nDets = module_folders.size();
    dqm_store.cd();

    int nDetsWithError = 0;
    std::string bad_module_folder = dname + "/" + "BadModuleList";
    if (dqm_store.dirExists(bad_module_folder)) {
      auto const meVec = dqm_store.getContents(bad_module_folder);
      for (auto me : meVec) {
        nDetsWithError++;
        uint16_t flag = me->getIntValue();
        std::string message;
        SiStripUtility::getBadModuleStatus(flag, message);
        str_val << me->getName() << " flag : " << me->getIntValue() << "  "
                << message << std::endl;
      }
    }
    str_val << "---------------------------------------------------------------"
               "-----\n"
            << " Detectors :  Total " << nDets << " with Error "
            << nDetsWithError << '\n'
            << "---------------------------------------------------------------"
               "-----\n";
    nDetsTotal += nDets;
    nDetsWithErrorTotal += nDetsWithError;
  }
  dqm_store.cd();
  str_val
    << "--------------------------------------------------------------------\n"
    << " Total Number of Connected Detectors : " << nDetsTotal << '\n'
    << " Total Number of Detectors with Error : " << nDetsWithErrorTotal << '\n'
    << "--------------------------------------------------------------------"
    << std::endl;
}