RunInfo_PayloadInspector.cc

Go to the documentation of this file.

 
#include "CondCore/Utilities/interface/PayloadInspectorModule.h"
#include "CondCore/Utilities/interface/PayloadInspector.h"
#include "CondCore/CondDB/interface/Time.h"
 
// the data format of the condition to be inspected
#include "CondFormats/RunInfo/interface/RunInfo.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
// helper
#include "CondCore/RunInfoPlugins/interface/RunInfoPayloadInspectoHelper.h"
 
// system includes
#include <memory>
#include <sstream>
#include <iostream>
 
// include ROOT
#include "TProfile.h"
#include "TH2F.h"
#include "TLegend.h"
#include "TCanvas.h"
#include "TLine.h"
#include "TStyle.h"
#include "TLatex.h"
#include "TPave.h"
#include "TPaveStats.h"
#include "TPaletteAxis.h"
 
namespace {
 
  /************************************************
     RunInfo Payload Inspector of 1 IOV 
  *************************************************/
  class RunInfoTest : public cond::payloadInspector::Histogram1D<RunInfo> {
  public:
    RunInfoTest() : cond::payloadInspector::Histogram1D<RunInfo>("Test RunInfo", "Test RunInfo", 10, 0.0, 10.0) {
      Base::setSingleIov(true);
    }
 
    bool fill() override {
      auto tag = PlotBase::getTag<0>();
      for (auto const& iov : tag.iovs) {
        std::shared_ptr<RunInfo> payload = Base::fetchPayload(std::get<1>(iov));
 
        if (payload.get()) {
          payload->printAllValues();
        }
      }
      return true;
    }
  };
 
  /************************************************
    Summary of RunInfo of 1 IOV 
  *************************************************/
  class RunInfoParameters : public cond::payloadInspector::PlotImage<RunInfo> {
  public:
    RunInfoParameters() : cond::payloadInspector::PlotImage<RunInfo>("Display of RunInfo parameters") {
      setSingleIov(true);
    }
 
    bool fill(const std::vector<std::tuple<cond::Time_t, cond::Hash> >& iovs) override {
      auto iov = iovs.front();
      std::shared_ptr<RunInfo> payload = fetchPayload(std::get<1>(iov));
 
      TCanvas canvas("Beam Spot Parameters Summary", "RunInfo Parameters summary", 1000, 1000);
      canvas.cd();
 
      gStyle->SetHistMinimumZero();
 
      canvas.SetTopMargin(0.08);
      canvas.SetBottomMargin(0.06);
      canvas.SetLeftMargin(0.3);
      canvas.SetRightMargin(0.02);
      canvas.Modified();
      canvas.SetGrid();
 
      auto h2_RunInfoParameters = std::unique_ptr<TH2F>(new TH2F("Parameters", "", 1, 0.0, 1.0, 11, 0, 11.));
      auto h2_RunInfoState = std::unique_ptr<TH2F>(new TH2F("State", "", 1, 0.0, 1.0, 11, 0, 11.));
      h2_RunInfoParameters->SetStats(false);
      h2_RunInfoState->SetStats(false);
 
      float fieldIntensity = RunInfoPI::theBField(payload->m_avg_current);
 
      std::function<float(RunInfoPI::parameters)> cutFunctor = [&payload,
                                                                fieldIntensity](RunInfoPI::parameters my_param) {
        float ret(-999.);
        switch (my_param) {
          case RunInfoPI::m_run:
            return float(payload->m_run);
          case RunInfoPI::m_start_time_ll:
            return float(payload->m_start_time_ll);
          case RunInfoPI::m_stop_time_ll:
            return float(payload->m_stop_time_ll);
          case RunInfoPI::m_start_current:
            return payload->m_start_current;
          case RunInfoPI::m_stop_current:
            return payload->m_stop_current;
          case RunInfoPI::m_avg_current:
            return payload->m_avg_current;
          case RunInfoPI::m_max_current:
            return payload->m_max_current;
          case RunInfoPI::m_min_current:
            return payload->m_min_current;
          case RunInfoPI::m_run_intervall_micros:
            return payload->m_run_intervall_micros;
          case RunInfoPI::m_BField:
            return fieldIntensity;
          case RunInfoPI::m_fedIN:
            return float((payload->m_fed_in).size());
          case RunInfoPI::END_OF_TYPES:
            return ret;
          default:
            return ret;
        }
      };
 
      h2_RunInfoParameters->GetXaxis()->SetBinLabel(1, "Value");
      h2_RunInfoState->GetXaxis()->SetBinLabel(1, "Value");
 
      unsigned int yBin = 11;
      for (int foo = RunInfoPI::m_run; foo != RunInfoPI::END_OF_TYPES; foo++) {
        RunInfoPI::parameters param = static_cast<RunInfoPI::parameters>(foo);
        std::string theLabel = RunInfoPI::getStringFromTypeEnum(param);
        h2_RunInfoState->GetYaxis()->SetBinLabel(yBin, theLabel.c_str());
        h2_RunInfoParameters->GetYaxis()->SetBinLabel(yBin, theLabel.c_str());
        h2_RunInfoParameters->SetBinContent(1, yBin, cutFunctor(param));
        // non-fake payload
        if ((payload->m_run) != -1) {
          if ((payload->m_avg_current) <= -1) {
            // go in error state
            h2_RunInfoState->SetBinContent(1, yBin, 0.);
          } else {
            // all is OK
            h2_RunInfoState->SetBinContent(1, yBin, 1.);
          }
        } else {
          // this is a fake payload
          h2_RunInfoState->SetBinContent(1, yBin, 0.9);
        }
        yBin--;
      }
 
      h2_RunInfoParameters->GetXaxis()->LabelsOption("h");
      h2_RunInfoParameters->GetYaxis()->SetLabelSize(0.05);
      h2_RunInfoParameters->GetXaxis()->SetLabelSize(0.05);
      h2_RunInfoParameters->SetMarkerSize(1.5);
 
      h2_RunInfoState->GetXaxis()->LabelsOption("h");
      h2_RunInfoState->GetYaxis()->SetLabelSize(0.05);
      h2_RunInfoState->GetXaxis()->SetLabelSize(0.05);
      h2_RunInfoState->SetMarkerSize(1.5);
 
      RunInfoPI::reportSummaryMapPalette(h2_RunInfoState.get());
      h2_RunInfoState->Draw("col");
 
      h2_RunInfoParameters->Draw("TEXTsame");
 
      TLatex t1;
      t1.SetNDC();
      t1.SetTextAlign(12);
      t1.SetTextSize(0.03);
      t1.DrawLatex(0.1, 0.98, "RunInfo parameters:");
      t1.DrawLatex(0.1, 0.95, "payload:");
 
      t1.SetTextFont(42);
      t1.SetTextColor(4);
      t1.DrawLatex(0.37, 0.982, Form("IOV %s", std::to_string(+std::get<0>(iov)).c_str()));
      t1.DrawLatex(0.21, 0.952, Form(" %s", (std::get<1>(iov)).c_str()));
 
      std::string fileName(m_imageFileName);
      canvas.SaveAs(fileName.c_str());
 
      return true;
    }
  };
 
  /************************************************
    time history of Magnet currents from RunInfo
  *************************************************/
 
  template <RunInfoPI::parameters param>
  class RunInfoCurrentHistory : public cond::payloadInspector::HistoryPlot<RunInfo, float> {
  public:
    RunInfoCurrentHistory()
        : cond::payloadInspector::HistoryPlot<RunInfo, float>(getStringFromTypeEnum(param),
                                                              getStringFromTypeEnum(param) + " value") {}
    ~RunInfoCurrentHistory() override = default;
 
    float getFromPayload(RunInfo& payload) override {
      float fieldIntensity = RunInfoPI::theBField(payload.m_avg_current);
 
      switch (param) {
        case RunInfoPI::m_start_current:
          return payload.m_start_current;
        case RunInfoPI::m_stop_current:
          return payload.m_stop_current;
        case RunInfoPI::m_avg_current:
          return payload.m_avg_current;
        case RunInfoPI::m_max_current:
          return payload.m_max_current;
        case RunInfoPI::m_min_current:
          return payload.m_min_current;
        case RunInfoPI::m_BField:
          return fieldIntensity;
        default:
          edm::LogWarning("LogicError") << "Unknown parameter: " << param;
          break;
      }
 
    }  // payload
 
    /************************************************/
    std::string getStringFromTypeEnum(const RunInfoPI::parameters& parameter) {
      switch (parameter) {
        case RunInfoPI::m_start_current:
          return "Magent start current [A]";
        case RunInfoPI::m_stop_current:
          return "Magnet stop current [A]";
        case RunInfoPI::m_avg_current:
          return "Magnet average current [A]";
        case RunInfoPI::m_max_current:
          return "Magnet max current [A]";
        case RunInfoPI::m_min_current:
          return "Magnet min current [A]";
        case RunInfoPI::m_BField:
          return "B-field intensity [T]";
        default:
          return "should never be here";
      }
    }
  };
 
  typedef RunInfoCurrentHistory<RunInfoPI::m_start_current> RunInfoStartCurrentHistory;
  typedef RunInfoCurrentHistory<RunInfoPI::m_stop_current> RunInfoStopCurrentHistory;
  typedef RunInfoCurrentHistory<RunInfoPI::m_avg_current> RunInfoAverageCurrentHistory;
  typedef RunInfoCurrentHistory<RunInfoPI::m_max_current> RunInfoMaxCurrentHistory;
  typedef RunInfoCurrentHistory<RunInfoPI::m_min_current> RunInfoMinCurrentHistory;
  typedef RunInfoCurrentHistory<RunInfoPI::m_BField> RunInfoBFieldHistory;
 
}  // namespace
 
PAYLOAD_INSPECTOR_MODULE(RunInfo) {
  PAYLOAD_INSPECTOR_CLASS(RunInfoTest);
  PAYLOAD_INSPECTOR_CLASS(RunInfoParameters);
  PAYLOAD_INSPECTOR_CLASS(RunInfoStopCurrentHistory);
  PAYLOAD_INSPECTOR_CLASS(RunInfoAverageCurrentHistory);
  PAYLOAD_INSPECTOR_CLASS(RunInfoMaxCurrentHistory);
  PAYLOAD_INSPECTOR_CLASS(RunInfoMinCurrentHistory);
  PAYLOAD_INSPECTOR_CLASS(RunInfoBFieldHistory);
}