SiStripDetVOffTrendPlotter.cc

Go to the documentation of this file.

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EDAnalyzer.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

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

#include "CondCore/CondDB/interface/ConnectionPool.h"

#include "CalibTracker/SiStripCommon/interface/SiStripDetInfoFileReader.h"
#include "CondFormats/SiStripObjects/interface/SiStripDetVOff.h"
#include "CondFormats/Common/interface/Time.h"
#include "CondFormats/Common/interface/TimeConversions.h"

#include <TROOT.h>
#include <TSystem.h>
#include <TCanvas.h>
#include <TFile.h>
#include <TLegend.h>
#include <TGraph.h>
#include <TH1.h>


class SiStripDetVOffTrendPlotter : public edm::EDAnalyzer {
public:
  const std::vector<Color_t> PLOT_COLORS {kRed, kBlue, kBlack, kOrange, kMagenta};

  explicit SiStripDetVOffTrendPlotter(const edm::ParameterSet& iConfig );
  ~SiStripDetVOffTrendPlotter() override;
  void analyze( const edm::Event& evt, const edm::EventSetup& evtSetup) override;
  void endJob() override;

private:
  std::string formatIOV(cond::Time_t iov, std::string format="%Y-%m-%d__%H_%M_%S");
  void prepGraph(TGraph *gr, TString name, TString title, Color_t color);
  void dumpCSV(bool isHV);

  cond::persistency::ConnectionPool m_connectionPool;
  std::string m_condDb;
  std::vector<std::string> m_plotTags;

  // Time interval (in hours) to go back for the plotting.
  int m_interval;
  // Or manually specify the start/end time. Format: "2002-01-20 23:59:59.000". Set m_interval to non-positive number to use this.
  std::string m_startTime;
  std::string m_endTime;
  // Specify output plot file name. Will use the timestamps if left empty.
  std::string m_outputPlot;
  // Specify output root file name. Leave empty if do not want to save plots in a root file.
  std::string m_outputRootFile;
  // Specify output CSV file name. Leave empty if do not want to dump HV/LV counts in a CSV file.
  std::string m_outputCSV;
  TFile *fout;
  edm::Service<SiStripDetInfoFileReader> detidReader;

  //          IOV                 TAG                #HV, #LV
  std::map<cond::Time_t, std::map<std::string, std::pair<int, int>>> iovMap;
};

SiStripDetVOffTrendPlotter::SiStripDetVOffTrendPlotter(const edm::ParameterSet& iConfig):
    m_connectionPool(),
    m_condDb( iConfig.getParameter< std::string >("conditionDatabase") ),
    m_plotTags( iConfig.getParameter< std::vector<std::string> >("plotTags") ),
    m_interval( iConfig.getParameter< int >("timeInterval") ),
    m_startTime( iConfig.getUntrackedParameter< std::string >("startTime", "") ),
    m_endTime( iConfig.getUntrackedParameter< std::string >("endTime", "") ),
    m_outputPlot( iConfig.getUntrackedParameter< std::string >("outputPlot", "") ),
    m_outputRootFile( iConfig.getUntrackedParameter< std::string >("outputRootFile", "") ),
    m_outputCSV( iConfig.getUntrackedParameter< std::string >("outputCSV", "") ),
    fout(nullptr){
  m_connectionPool.setParameters( iConfig.getParameter<edm::ParameterSet>("DBParameters")  );
  m_connectionPool.configure();
  if (m_outputRootFile!="") fout = new TFile(m_outputRootFile.data(), "RECREATE");
}

SiStripDetVOffTrendPlotter::~SiStripDetVOffTrendPlotter() {
  if (fout) fout->Close();
}

void SiStripDetVOffTrendPlotter::analyze(const edm::Event& evt, const edm::EventSetup& evtSetup) {

  // get total number of modules
  auto num_modules = detidReader->getAllDetIds().size();

  // get start and end time for DB query
  boost::posix_time::ptime p_start, p_end;
  if (m_interval > 0){
    // from m_interval hours ago to now
    p_end = boost::posix_time::second_clock::universal_time();
    p_start = p_end - boost::posix_time::hours(m_interval);
  }else {
    // use start and end time from config file
    p_start = boost::posix_time::time_from_string(m_startTime);
    p_end   = boost::posix_time::time_from_string(m_endTime);
  }
  cond::Time_t startIov = cond::time::from_boost(p_start);
  cond::Time_t endIov   = cond::time::from_boost(p_end);
  if (startIov > endIov)
    throw cms::Exception("endTime must be greater than startTime!");
  edm::LogInfo("SiStripDetVOffTrendPlotter") << "[SiStripDetVOffTrendPlotter::" << __func__ << "] "
      << "Set start IOV " << startIov << " (" << boost::posix_time::to_simple_string(p_start) << ")"
      << "\n ... Set end IOV " << endIov << " (" << boost::posix_time::to_simple_string(p_end) << ")" ;

  // open db session
  edm::LogInfo("SiStripDetVOffTrendPlotter") << "[SiStripDetVOffTrendPlotter::" << __func__ << "] "
      << "Query the condition database " << m_condDb;
  cond::persistency::Session condDbSession = m_connectionPool.createSession( m_condDb );
  condDbSession.transaction().start( true );

  // loop over all tags to plot
  std::vector<TGraph*> hvgraphs, lvgraphs;
  TLegend *leg_hv = new TLegend(0.6, 0.87, 0.99, 0.99);
  TLegend *leg_lv = new TLegend(0.6, 0.87, 0.99, 0.99);
  for (unsigned itag=0; itag<m_plotTags.size(); ++itag){
    auto tag = m_plotTags.at(itag);
    auto color = itag<PLOT_COLORS.size() ? PLOT_COLORS.at(itag) : kGreen+itag;

    std::vector<double> vTime;
    std::vector<double> vHVOffPercent, vLVOffPercent;

    // query the database
    edm::LogInfo("SiStripDetVOffTrendPlotter") << "[SiStripDetVOffTrendPlotter::" << __func__ << "] "
        << "Reading IOVs from tag " << tag;
    cond::persistency::IOVProxy iovProxy = condDbSession.readIov(tag, true); // load all?
    auto iiov = iovProxy.find(startIov);
    auto eiov = iovProxy.find(endIov);
    int niov = 0;
    while (iiov != iovProxy.end() && (*iiov).since <= (*eiov).since){
      // convert cond::Time_t to seconds since epoch
      if ((*iiov).since<startIov)
        vTime.push_back(cond::time::unpack(startIov).first);
      else
        vTime.push_back(cond::time::unpack((*iiov).since).first);
      auto payload = condDbSession.fetchPayload<SiStripDetVOff>( (*iiov).payloadId );
      vHVOffPercent.push_back( 1.0*payload->getHVoffCounts()/num_modules );
      vLVOffPercent.push_back( 1.0*payload->getLVoffCounts()/num_modules );
      iovMap[(*iiov).since][tag] = {payload->getHVoffCounts(), payload->getLVoffCounts()};
      // debug
      std::cout << boost::posix_time::to_simple_string(cond::time::to_boost((*iiov).since))
          << " (" << (*iiov).since <<  ")"
          << ", # HV Off=" << std::setw(6) << payload->getHVoffCounts()
          << ", # LV Off=" << std::setw(6) << payload->getLVoffCounts() << std::endl;
      ++iiov;
      ++niov;
    }
    edm::LogInfo("SiStripDetVOffTrendPlotter") << "[SiStripDetVOffTrendPlotter::" << __func__ << "] "
        << "Read " << niov << " IOVs from tag " << tag << " in the specified interval.";

    TGraph *hv = new TGraph(vTime.size(), vTime.data(), vHVOffPercent.data());
    prepGraph(hv, TString("HVOff_")+tag, ";UTC;Fraction of HV off", color);
    leg_hv->AddEntry(hv, tag.data(), "LP");

    TGraph *lv = new TGraph(vTime.size(), vTime.data(), vLVOffPercent.data());
    prepGraph(lv, TString("LVOff_")+tag, ";UTC;Fraction of LV off", color);
    leg_lv->AddEntry(lv, tag.data(), "LP");

    hvgraphs.push_back(hv);
    lvgraphs.push_back(lv);
  }

  condDbSession.transaction().commit();

  // Make plots
  TCanvas c("c", "c", 1800, 1200);
  c.SetTopMargin(0.12);
  c.SetBottomMargin(0.08);
  c.SetGridx();
  c.SetGridy();
  for (const auto hv : hvgraphs){
    if (hv==hvgraphs.front())
      hv->Draw("ALP");
    else
      hv->Draw("LPsame");
    if (fout){
      fout->cd();
      hv->Write();
    }
  }
  leg_hv->Draw();
  std::string plot_postfix = m_outputPlot!="" ? m_outputPlot : "from_" + formatIOV(startIov) + "_to_" + formatIOV(endIov) + ".png";
  c.Print( ("HVOff_" + plot_postfix).data() );

  c.Clear();
  for (const auto lv : lvgraphs){
    if (lv==lvgraphs.front())
      lv->Draw("ALP");
    else
      lv->Draw("LPsame");
    if (fout){
      fout->cd();
      lv->Write();
    }
  }
  leg_lv->Draw();
  c.Print( ("LVOff_" + plot_postfix).data() );

  if (m_outputCSV!="") {
    dumpCSV(true);
    dumpCSV(false);
  }

}

void SiStripDetVOffTrendPlotter::endJob() {
}

std::string SiStripDetVOffTrendPlotter::formatIOV(cond::Time_t iov, std::string format) {
  auto facet = new boost::posix_time::time_facet(format.c_str());
   std::ostringstream stream;
   stream.imbue(std::locale(stream.getloc(), facet));
   stream << cond::time::to_boost(iov);
   return stream.str();
}

void SiStripDetVOffTrendPlotter::prepGraph(TGraph* gr, TString name, TString title, Color_t color) {
  gr->SetName(name);
  gr->SetTitle(title);
  gr->SetLineColor(color);
  gr->SetLineWidth(2);
  gr->SetMarkerStyle(20);
  gr->SetMarkerSize(1.5);
  gr->SetMarkerColor(color);
  gr->GetXaxis()->SetTimeDisplay(1);
  gr->GetXaxis()->SetLabelOffset(0.02);
  gr->GetXaxis()->SetTimeFormat("#splitline{%b %d}{%H:%M}");
  gr->GetXaxis()->SetTimeOffset(0, "gmt");
  gr->GetXaxis()->SetLabelSize(0.025);
  gr->GetXaxis()->SetTitleSize(0.025);
  gr->GetXaxis()->SetTitleOffset(1.6);
  gr->GetYaxis()->SetRangeUser(0, 1.05);
}

void SiStripDetVOffTrendPlotter::dumpCSV(bool isHV) {

  // get total number of modules
  auto num_modules = detidReader->getAllDetIds().size();

  std::string outCSV = isHV ? "HVOff_table_"+m_outputCSV : "LVOff_table_"+m_outputCSV;
  std::ofstream csv;
  csv.open(outCSV);
  csv << "IOV,Timestamp(UTC),";
  for (const auto &tag : m_plotTags) csv << tag << ",";
  csv << std::endl;

  csv << std::fixed << std::setprecision(1);

  for (const auto &v : iovMap){
    auto iov = v.first;
    auto timestamp = boost::posix_time::to_simple_string(cond::time::to_boost(iov));
    csv << iov << "," << timestamp << ",";
    for (const auto &tag : m_plotTags){
      if (v.second.find(tag)!=v.second.end()){
        int count = isHV ? v.second.at(tag).first : v.second.at(tag).second;
        csv << count << " (" << 100.*count/num_modules << "%)";
      }
        csv << ",";
    }
    csv << std::endl;
  }

  csv.close();
}

DEFINE_FWK_MODULE(SiStripDetVOffTrendPlotter);