File indexing completed on 2021-02-14 14:33:58
0001 #include "Validation/RecoTau/plugins/DQMHistPlotter.h"
0002
0003 #include "Validation/RecoTau/plugins/dqmAuxFunctions.h"
0004
0005
0006 #include "FWCore/Framework/interface/Frameworkfwd.h"
0007 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0008
0009
0010 #include "DQMServices/Core/interface/DQMStore.h"
0011 #include "FWCore/ServiceRegistry/interface/Service.h"
0012
0013 #include <TCanvas.h>
0014 #include <TPad.h>
0015 #include <TPostScript.h>
0016 #include <TStyle.h>
0017 #include <TROOT.h>
0018 #include <TMath.h>
0019
0020 #include <iostream>
0021
0022
0023 const std::string type_smMC = "smMC";
0024 const std::string type_bsmMC = "bsmMC";
0025 const std::string type_smSumMC = "smSumMC";
0026 const std::string type_Data = "Data";
0027
0028
0029 const double defaultMinX = -1.;
0030 const double defaultMaxX = -1.;
0031 const double defaultXaxisTitleOffset = 1.0;
0032 const double defaultXaxisTitleSize = 0.05;
0033
0034
0035 const double defaultMinY_linear = 0.;
0036 const double defaultMinY_log = 1.e-2;
0037 const double defaultMaxY_linear = -1.;
0038 const double defaultMaxY_log = -1.;
0039 const std::string yScale_linear = "linear";
0040 const std::string yScale_log = "log";
0041 const std::string defaultYscale = yScale_linear;
0042 const double defaultYaxisTitleOffset = 1.0;
0043 const double defaultYaxisTitleSize = 0.05;
0044 const double defaultYaxisMaximumScaleFactor_linear = 1.6;
0045 const double defaultYaxisMaximumScaleFactor_log = 5.e+2;
0046
0047
0048 const double defaultLegendPosX = 0.50;
0049 const double defaultLegendPosY = 0.55;
0050 const double defaultLegendSizeX = 0.39;
0051 const double defaultLegendSizeY = 0.34;
0052 const std::string defaultLegendHeader = "";
0053 const std::string defaultLegendOptions = "brNDC";
0054 const int defaultLegendBorderSize = 0;
0055 const int defaultLegendFillColor = 0;
0056
0057
0058 const double defaultLabelPosX = 0.66;
0059 const double defaultLabelPosY = 0.82;
0060 const double defaultLabelSizeX = 0.26;
0061 const double defaultLabelSizeY = 0.10;
0062 const std::string defaultLabelOptions = "brNDC";
0063 const int defaultLabelBorderSize = 0;
0064 const int defaultLabelFillColor = 0;
0065 const int defaultLabelTextColor = 1;
0066 const double defaultLabelTextSize = 0.05;
0067 const int defaultLabelTextAlign = 22;
0068 const double defaultLabelTextAngle = 0.;
0069
0070
0071 const int defaultMarkerColor = 1;
0072 const int defaultMarkerSize = 1;
0073 const int defaultMarkerStyle = 2;
0074 const int defaultLineColor = 0;
0075 const int defaultLineStyle = 1;
0076 const int defaultLineWidth = 2;
0077 const int defaultFillColor = 0;
0078 const int defaultFillStyle = 1001;
0079 const std::string defaultDrawOption = "";
0080 const std::string defaultDrawOptionLegend = "lpf";
0081
0082 const std::string drawOption_eBand = "eBand";
0083
0084
0085 const int defaultCanvasSizeX = 800;
0086 const int defaultCanvasSizeY = 600;
0087
0088 const std::string drawOptionSeparator = "#.#";
0089
0090 const int verbosity = 0;
0091
0092 template <class T>
0093 void checkCfgDef(const std::string& cfgEntryName,
0094 std::map<std::string, T>& def,
0095 int& errorFlag,
0096 const std::string& defType,
0097 const std::string& drawJobName) {
0098 if (def.find(cfgEntryName) == def.end()) {
0099 edm::LogError("checkCfgDef") << " " << defType << " = " << cfgEntryName
0100 << " undefined, needed by drawJob = " << drawJobName << " !!";
0101 errorFlag = 1;
0102 }
0103 }
0104
0105 template <class T>
0106 void checkCfgDefs(const std::vector<std::string>& cfgEntryNames,
0107 std::map<std::string, T>& def,
0108 int& errorFlag,
0109 const std::string& defType,
0110 const std::string& drawJobName) {
0111 for (std::vector<std::string>::const_iterator cfgEntryName = cfgEntryNames.begin();
0112 cfgEntryName != cfgEntryNames.end();
0113 ++cfgEntryName) {
0114 checkCfgDef(*cfgEntryName, def, errorFlag, defType, drawJobName);
0115 }
0116 }
0117
0118 template <class T>
0119 const T* findCfgDef(const std::string& cfgEntryName,
0120 std::map<std::string, T>& def,
0121 const std::string& defType,
0122 const std::string& drawJobName) {
0123 typename std::map<std::string, T>::const_iterator it = def.find(cfgEntryName);
0124 if (it != def.end()) {
0125 return &(it->second);
0126 } else {
0127 edm::LogError("findCfgDef") << " " << defType << " = " << cfgEntryName
0128 << " undefined, needed by drawJob = " << drawJobName << " !!";
0129 return nullptr;
0130 }
0131 }
0132
0133
0134
0135
0136
0137 typedef std::pair<TH1*, std::string> histoDrawEntry;
0138
0139 void drawHistograms(const std::list<histoDrawEntry>& histogramList, bool& isFirstHistogram) {
0140 for (std::list<histoDrawEntry>::const_iterator it = histogramList.begin(); it != histogramList.end(); ++it) {
0141 std::string drawOption = (isFirstHistogram) ? it->second : std::string(it->second).append("same");
0142 it->first->Draw(drawOption.data());
0143 isFirstHistogram = false;
0144 }
0145 }
0146
0147
0148
0149
0150
0151 bool find_vstring(const std::vector<std::string>& vs, const std::string& s) {
0152 for (std::vector<std::string>::const_iterator it = vs.begin(); it != vs.end(); ++it) {
0153 if ((*it) == s)
0154 return true;
0155 }
0156 return false;
0157 }
0158
0159
0160
0161
0162
0163 TauDQMHistPlotter::cfgEntryProcess::cfgEntryProcess(const std::string& name, const edm::ParameterSet& cfg) {
0164 name_ = name;
0165
0166 dqmDirectory_ = cfg.getParameter<std::string>("dqmDirectory");
0167
0168 legendEntry_ = cfg.getParameter<std::string>("legendEntry");
0169 legendEntryErrorBand_ = (cfg.exists("legendEntryErrorBand")) ? cfg.getParameter<std::string>("legendEntryErrorBand")
0170 : std::string(legendEntry_).append(" Uncertainty");
0171
0172 type_ = cfg.getParameter<std::string>("type");
0173
0174 if (verbosity)
0175 print();
0176 }
0177
0178 void TauDQMHistPlotter::cfgEntryProcess::print() const {
0179 std::cout << "<TauDQMHistPlotter::cfgEntryProcess::print>:" << std::endl;
0180 std::cout << " name = " << name_ << std::endl;
0181 std::cout << " dqmDirectory = " << dqmDirectory_ << std::endl;
0182 std::cout << " legendEntry = " << legendEntry_ << std::endl;
0183 std::cout << " legendEntryErrorBand = " << legendEntryErrorBand_ << std::endl;
0184 std::cout << " type = " << type_ << std::endl;
0185 }
0186
0187
0188
0189
0190
0191 TauDQMHistPlotter::cfgEntryAxisX::cfgEntryAxisX(const std::string& name, const edm::ParameterSet& cfg) {
0192 name_ = name;
0193
0194 minX_ = (cfg.exists("minX")) ? cfg.getParameter<double>("minX") : defaultMinX;
0195 maxX_ = (cfg.exists("maxX")) ? cfg.getParameter<double>("maxX") : defaultMaxX;
0196 xAxisTitle_ = cfg.getParameter<std::string>("xAxisTitle");
0197 xAxisTitleOffset_ =
0198 (cfg.exists("xAxisTitleOffset")) ? cfg.getParameter<double>("xAxisTitleOffset") : defaultXaxisTitleOffset;
0199 xAxisTitleSize_ = (cfg.exists("xAxisTitleSize")) ? cfg.getParameter<double>("xAxisTitleSize") : defaultXaxisTitleSize;
0200
0201 if (verbosity)
0202 print();
0203 }
0204
0205 void TauDQMHistPlotter::cfgEntryAxisX::print() const {
0206 std::cout << "<TauDQMHistPlotter::cfgEntryAxisX::print>:" << std::endl;
0207 std::cout << " name = " << name_ << std::endl;
0208 std::cout << " minX_ = " << minX_ << std::endl;
0209 std::cout << " maxX_ = " << maxX_ << std::endl;
0210 std::cout << " xAxisTitle = " << xAxisTitle_ << std::endl;
0211 std::cout << " xAxisTitleOffset = " << xAxisTitleOffset_ << std::endl;
0212 std::cout << " xAxisTitleSize = " << xAxisTitleSize_ << std::endl;
0213 }
0214
0215 void TauDQMHistPlotter::cfgEntryAxisX::applyTo(TH1* histogram) const {
0216 if (histogram) {
0217 double xMin = (minX_ != defaultMinX) ? minX_ : histogram->GetXaxis()->GetXmin();
0218 double xMax = (maxX_ != defaultMaxX) ? maxX_ : histogram->GetXaxis()->GetXmax();
0219 histogram->SetAxisRange(xMin, xMax, "X");
0220 histogram->GetXaxis()->SetTitle(xAxisTitle_.data());
0221 histogram->GetXaxis()->SetTitleOffset(xAxisTitleOffset_);
0222 histogram->GetXaxis()->SetTitleSize(xAxisTitleSize_);
0223 }
0224 }
0225
0226
0227
0228
0229
0230 TauDQMHistPlotter::cfgEntryAxisY::cfgEntryAxisY(const std::string& name, const edm::ParameterSet& cfg) {
0231 name_ = name;
0232
0233 minY_linear_ = (cfg.exists("minY_linear")) ? cfg.getParameter<double>("minY_linear") : defaultMinY_linear;
0234 minY_log_ = (cfg.exists("minY_log")) ? cfg.getParameter<double>("minY_log") : defaultMinY_log;
0235 maxY_linear_ = (cfg.exists("maxY_linear")) ? cfg.getParameter<double>("maxY_linear") : defaultMaxY_linear;
0236 maxY_log_ = (cfg.exists("maxY_log")) ? cfg.getParameter<double>("maxY_log") : defaultMaxY_log;
0237 yScale_ = (cfg.exists("yScale")) ? cfg.getParameter<std::string>("yScale") : defaultYscale;
0238 yAxisTitle_ = cfg.getParameter<std::string>("yAxisTitle");
0239 yAxisTitleOffset_ =
0240 (cfg.exists("yAxisTitleOffset")) ? cfg.getParameter<double>("yAxisTitleOffset") : defaultYaxisTitleOffset;
0241 yAxisTitleSize_ = (cfg.exists("yAxisTitleSize")) ? cfg.getParameter<double>("yAxisTitleSize") : defaultYaxisTitleSize;
0242
0243 if (verbosity)
0244 print();
0245 }
0246
0247 void TauDQMHistPlotter::cfgEntryAxisY::print() const {
0248 std::cout << "<TauDQMHistPlotter::cfgEntryAxisY::print>:" << std::endl;
0249 std::cout << " name = " << name_ << std::endl;
0250 std::cout << " minY_linear = " << minY_linear_ << std::endl;
0251 std::cout << " minY_log = " << minY_log_ << std::endl;
0252 std::cout << " maxY_linear = " << maxY_linear_ << std::endl;
0253 std::cout << " maxY_log = " << maxY_log_ << std::endl;
0254 std::cout << " yScale = " << yScale_ << std::endl;
0255 std::cout << " yAxisTitle = " << yAxisTitle_ << std::endl;
0256 std::cout << " yAxisTitleOffset = " << yAxisTitleOffset_ << std::endl;
0257 std::cout << " yAxisTitleSize = " << yAxisTitleSize_ << std::endl;
0258 }
0259
0260 void TauDQMHistPlotter::cfgEntryAxisY::applyTo(TH1* histogram, double norm) const {
0261 if (histogram) {
0262 bool yLogScale = (yScale_ == yScale_log) ? true : false;
0263 double minY = (yLogScale) ? minY_log_ : minY_linear_;
0264 histogram->SetMinimum(minY);
0265 double maxY = (yLogScale) ? maxY_log_ : maxY_linear_;
0266 double defaultMaxY = (yLogScale) ? defaultMaxY_log : defaultMaxY_linear;
0267 if (maxY != defaultMaxY) {
0268
0269 histogram->SetMaximum(maxY);
0270 } else {
0271
0272
0273
0274 double defaultYaxisMaximumScaleFactor =
0275 (yLogScale) ? defaultYaxisMaximumScaleFactor_log : defaultYaxisMaximumScaleFactor_linear;
0276 histogram->SetMaximum(defaultYaxisMaximumScaleFactor * norm);
0277 }
0278 histogram->GetYaxis()->SetTitle(yAxisTitle_.data());
0279 histogram->GetYaxis()->SetTitleOffset(yAxisTitleOffset_);
0280 histogram->GetYaxis()->SetTitleSize(yAxisTitleSize_);
0281 }
0282 }
0283
0284
0285
0286
0287
0288 TauDQMHistPlotter::cfgEntryLegend::cfgEntryLegend(const std::string& name, const edm::ParameterSet& cfg) {
0289 name_ = name;
0290
0291 posX_ = (cfg.exists("posX")) ? cfg.getParameter<double>("posX") : defaultLegendPosX;
0292 posY_ = (cfg.exists("posY")) ? cfg.getParameter<double>("posY") : defaultLegendPosY;
0293 sizeX_ = (cfg.exists("sizeX")) ? cfg.getParameter<double>("sizeX") : defaultLegendSizeX;
0294 sizeY_ = (cfg.exists("sizeY")) ? cfg.getParameter<double>("sizeY") : defaultLegendSizeY;
0295 header_ = (cfg.exists("header")) ? cfg.getParameter<std::string>("header") : defaultLegendHeader;
0296 option_ = (cfg.exists("option")) ? cfg.getParameter<std::string>("option") : defaultLegendOptions;
0297 borderSize_ = (cfg.exists("borderSize")) ? cfg.getParameter<int>("borderSize") : defaultLegendBorderSize;
0298 fillColor_ = (cfg.exists("fillColor")) ? cfg.getParameter<int>("fillColor") : defaultLegendFillColor;
0299
0300 if (verbosity)
0301 print();
0302 }
0303
0304 void TauDQMHistPlotter::cfgEntryLegend::print() const {
0305 std::cout << "<TauDQMHistPlotter::cfgEntryLegend::print>:" << std::endl;
0306 std::cout << " name = " << name_ << std::endl;
0307 std::cout << " posX = " << posX_ << std::endl;
0308 std::cout << " posY = " << posY_ << std::endl;
0309 std::cout << " sizeX = " << sizeX_ << std::endl;
0310 std::cout << " sizeY = " << sizeY_ << std::endl;
0311 std::cout << " header = " << header_ << std::endl;
0312 std::cout << " option = " << option_ << std::endl;
0313 std::cout << " borderSize = " << borderSize_ << std::endl;
0314 std::cout << " fillColor = " << fillColor_ << std::endl;
0315 }
0316
0317 void TauDQMHistPlotter::cfgEntryLegend::applyTo(TLegend* legend) const {
0318 if (legend) {
0319 legend->SetX1(posX_);
0320 legend->SetY1(posY_);
0321 legend->SetX2(posX_ + sizeX_);
0322 legend->SetY2(posY_ + sizeY_);
0323 legend->SetHeader(header_.data());
0324 legend->SetOption(option_.data());
0325 legend->SetBorderSize(borderSize_);
0326 legend->SetFillColor(fillColor_);
0327 }
0328 }
0329
0330
0331
0332
0333
0334 TauDQMHistPlotter::cfgEntryLabel::cfgEntryLabel(const std::string& name, const edm::ParameterSet& cfg) {
0335 name_ = name;
0336
0337 posX_ = (cfg.exists("posX")) ? cfg.getParameter<double>("posX") : defaultLabelPosX;
0338 posY_ = (cfg.exists("posY")) ? cfg.getParameter<double>("posY") : defaultLabelPosY;
0339 sizeX_ = (cfg.exists("sizeX")) ? cfg.getParameter<double>("sizeX") : defaultLabelSizeX;
0340 sizeY_ = (cfg.exists("sizeY")) ? cfg.getParameter<double>("sizeY") : defaultLabelSizeY;
0341 option_ = (cfg.exists("option")) ? cfg.getParameter<std::string>("option") : defaultLabelOptions;
0342 borderSize_ = (cfg.exists("borderSize")) ? cfg.getParameter<int>("borderSize") : defaultLabelBorderSize;
0343 fillColor_ = (cfg.exists("fillColor")) ? cfg.getParameter<int>("fillColor") : defaultLabelFillColor;
0344 textColor_ = (cfg.exists("textColor")) ? cfg.getParameter<int>("textColor") : defaultLabelTextColor;
0345 textSize_ = (cfg.exists("textSize")) ? cfg.getParameter<double>("textSize") : defaultLabelTextSize;
0346 textAlign_ = (cfg.exists("textAlign")) ? cfg.getParameter<int>("textAlign") : defaultLabelTextAlign;
0347 textAngle_ = (cfg.exists("textAngle")) ? cfg.getParameter<double>("textAngle") : defaultLabelTextAngle;
0348 text_ = cfg.getParameter<vstring>("text");
0349
0350 if (verbosity)
0351 print();
0352 }
0353
0354 void TauDQMHistPlotter::cfgEntryLabel::print() const {
0355 std::cout << "<TauDQMHistPlotter::cfgEntryLabel::print>:" << std::endl;
0356 std::cout << " name = " << name_ << std::endl;
0357 std::cout << " posX = " << posX_ << std::endl;
0358 std::cout << " posY = " << posY_ << std::endl;
0359 std::cout << " sizeX = " << sizeX_ << std::endl;
0360 std::cout << " sizeY = " << sizeY_ << std::endl;
0361 std::cout << " option = " << option_ << std::endl;
0362 std::cout << " borderSize = " << borderSize_ << std::endl;
0363 std::cout << " fillColor = " << fillColor_ << std::endl;
0364 std::cout << " textColor = " << textColor_ << std::endl;
0365 std::cout << " textSize = " << textSize_ << std::endl;
0366 std::cout << " textAlign = " << textAlign_ << std::endl;
0367 std::cout << " textAngle = " << textAngle_ << std::endl;
0368 std::cout << " text = " << format_vstring(text_) << std::endl;
0369 }
0370
0371 void TauDQMHistPlotter::cfgEntryLabel::applyTo(TPaveText* label) const {
0372 if (label) {
0373
0374
0375
0376
0377 label->SetX1NDC(posX_);
0378 label->SetY1NDC(posY_);
0379 label->SetX2NDC(posX_ + sizeX_);
0380 label->SetY2NDC(posY_ + sizeY_);
0381 label->SetOption(option_.data());
0382 label->SetBorderSize(borderSize_);
0383 label->SetFillColor(fillColor_);
0384 label->SetTextColor(textColor_);
0385 label->SetTextSize(textSize_);
0386 label->SetTextAlign(textAlign_);
0387 label->SetTextAngle(textAngle_);
0388 for (vstring::const_iterator line = text_.begin(); line != text_.end(); ++line) {
0389 label->AddText(line->data());
0390 }
0391 }
0392 }
0393
0394
0395
0396
0397
0398 TauDQMHistPlotter::cfgEntryDrawOption::cfgEntryDrawOption(const std::string& name, const edm::ParameterSet& cfg) {
0399 name_ = name;
0400
0401 markerColor_ = (cfg.exists("markerColor")) ? cfg.getParameter<int>("markerColor") : defaultMarkerColor;
0402 markerSize_ = (cfg.exists("markerSize")) ? cfg.getParameter<double>("markerSize") : defaultMarkerSize;
0403 markerStyle_ = (cfg.exists("markerStyle")) ? cfg.getParameter<int>("markerStyle") : defaultMarkerStyle;
0404
0405 lineColor_ = (cfg.exists("lineColor")) ? cfg.getParameter<int>("lineColor") : defaultLineColor;
0406 lineStyle_ = (cfg.exists("lineStyle")) ? cfg.getParameter<int>("lineStyle") : defaultLineStyle;
0407 lineWidth_ = (cfg.exists("lineWidth")) ? cfg.getParameter<int>("lineWidth") : defaultLineWidth;
0408
0409 fillColor_ = (cfg.exists("fillColor")) ? cfg.getParameter<int>("fillColor") : defaultFillColor;
0410 fillStyle_ = (cfg.exists("fillStyle")) ? cfg.getParameter<int>("fillStyle") : defaultFillStyle;
0411
0412 drawOption_ = (cfg.exists("drawOption")) ? cfg.getParameter<std::string>("drawOption") : defaultDrawOption;
0413 drawOptionLegend_ =
0414 (cfg.exists("drawOptionLegend")) ? cfg.getParameter<std::string>("drawOptionLegend") : defaultDrawOptionLegend;
0415
0416 if (verbosity)
0417 print();
0418 }
0419
0420 TauDQMHistPlotter::cfgEntryDrawOption::cfgEntryDrawOption(const std::string& name, const cfgEntryDrawOption& blueprint)
0421 : name_(name),
0422 markerColor_(blueprint.markerColor_),
0423 markerSize_(blueprint.markerSize_),
0424 markerStyle_(blueprint.markerStyle_),
0425 lineColor_(blueprint.lineColor_),
0426 lineStyle_(blueprint.lineStyle_),
0427 lineWidth_(blueprint.lineWidth_),
0428 fillColor_(blueprint.fillColor_),
0429 fillStyle_(blueprint.fillStyle_),
0430 drawOption_(blueprint.drawOption_),
0431 drawOptionLegend_(blueprint.drawOptionLegend_) {
0432 if (verbosity)
0433 print();
0434 }
0435
0436 void TauDQMHistPlotter::cfgEntryDrawOption::print() const {
0437 std::cout << "<TauDQMHistPlotter::cfgEntryDrawOption::print>:" << std::endl;
0438 std::cout << " name = " << name_ << std::endl;
0439 std::cout << " markerColor = " << markerColor_ << std::endl;
0440 std::cout << " markerSize = " << markerSize_ << std::endl;
0441 std::cout << " markerStyle = " << markerStyle_ << std::endl;
0442 std::cout << " lineColor = " << lineColor_ << std::endl;
0443 std::cout << " lineStyle = " << lineStyle_ << std::endl;
0444 std::cout << " lineWidth = " << lineWidth_ << std::endl;
0445 std::cout << " fillColor = " << fillColor_ << std::endl;
0446 std::cout << " fillStyle = " << fillStyle_ << std::endl;
0447 std::cout << " drawOption = " << drawOption_ << std::endl;
0448 std::cout << " drawOptionLegend = " << drawOptionLegend_ << std::endl;
0449 }
0450
0451 void TauDQMHistPlotter::cfgEntryDrawOption::applyTo(TH1* histogram) const {
0452 if (histogram) {
0453 histogram->SetMarkerColor(markerColor_);
0454 histogram->SetMarkerSize(markerSize_);
0455 histogram->SetMarkerStyle(markerStyle_);
0456 histogram->SetLineColor(lineColor_);
0457 histogram->SetLineStyle(lineStyle_);
0458 histogram->SetLineWidth(lineWidth_);
0459 histogram->SetFillColor(fillColor_);
0460 histogram->SetFillStyle(fillStyle_);
0461 }
0462 }
0463
0464
0465
0466
0467
0468 TauDQMHistPlotter::plotDefEntry::plotDefEntry(const std::string& dqmMonitorElement,
0469 const std::string& drawOptionEntry,
0470 const std::string& legendEntry,
0471 const std::string& legendEntryErrorBand,
0472 const std::string& process,
0473 bool doStack)
0474 : dqmMonitorElement_(dqmMonitorElement),
0475 drawOptionEntry_(drawOptionEntry),
0476 legendEntry_(legendEntry),
0477 legendEntryErrorBand_(legendEntryErrorBand),
0478 process_(process),
0479 doStack_(doStack),
0480 isErrorBand_(false) {
0481
0482 }
0483
0484 TauDQMHistPlotter::plotDefEntry::plotDefEntry(const plotDefEntry& blueprint)
0485 : dqmMonitorElement_(blueprint.dqmMonitorElement_),
0486 drawOptionEntry_(blueprint.drawOptionEntry_),
0487 legendEntry_(blueprint.legendEntry_),
0488 legendEntryErrorBand_(blueprint.legendEntryErrorBand_),
0489 process_(blueprint.process_),
0490 doStack_(blueprint.doStack_),
0491 isErrorBand_(false) {
0492
0493 }
0494
0495 void TauDQMHistPlotter::plotDefEntry::print() const {
0496 std::cout << "<TauDQMHistPlotter::plotDefEntry::print>:" << std::endl;
0497 std::cout << " dqmMonitorElement = " << dqmMonitorElement_ << std::endl;
0498 std::cout << " drawOptionEntry = " << drawOptionEntry_ << std::endl;
0499 std::cout << " legendEntry = " << legendEntry_ << std::endl;
0500 std::cout << " legendEntryErrorBand = " << legendEntryErrorBand_ << std::endl;
0501 std::cout << " process = " << process_ << std::endl;
0502 std::cout << " doStack = " << doStack_ << std::endl;
0503 }
0504
0505
0506
0507
0508
0509 TauDQMHistPlotter::cfgEntryDrawJob::cfgEntryDrawJob(const std::string& name,
0510 const plotDefList& plotDefList,
0511 const std::string& title,
0512 const std::string& xAxis,
0513 const std::string& yAxis,
0514 const std::string& legend,
0515 const vstring& labels) {
0516 name_ = name;
0517
0518 for (plotDefList::const_iterator it = plotDefList.begin(); it != plotDefList.end(); ++it) {
0519 plots_.push_back(plotDefEntry(*it));
0520 }
0521
0522 title_ = title;
0523
0524 xAxis_ = xAxis;
0525 yAxis_ = yAxis;
0526
0527 legend_ = legend;
0528
0529 for (vstring::const_iterator it = labels.begin(); it != labels.end(); ++it) {
0530 labels_.push_back(std::string(*it));
0531 }
0532
0533 if (verbosity)
0534 print();
0535 }
0536
0537 void TauDQMHistPlotter::cfgEntryDrawJob::print() const {
0538 std::cout << "<TauDQMHistPlotter::cfgSetDrawJob::print>:" << std::endl;
0539 std::cout << " name = " << name_ << std::endl;
0540 std::cout << "plots = {" << std::endl;
0541 for (plotDefList::const_iterator plot = plots_.begin(); plot != plots_.end(); ++plot) {
0542 plot->print();
0543 }
0544 std::cout << "}" << std::endl;
0545 std::cout << " title = " << title_ << std::endl;
0546 std::cout << " xAxis = " << xAxis_ << std::endl;
0547 std::cout << " yAxis = " << yAxis_ << std::endl;
0548 std::cout << " legend = " << legend_ << std::endl;
0549 std::cout << " labels = " << format_vstring(labels_) << std::endl;
0550 }
0551
0552
0553
0554
0555
0556 TauDQMHistPlotter::TauDQMHistPlotter(const edm::ParameterSet& cfg) {
0557 if (verbosity)
0558 std::cout << "<TauDQMHistPlotter::TauDQMHistPlotter>:" << std::endl;
0559
0560 toFile_ = cfg.getParameter<bool>("PrintToFile");
0561 cfgError_ = 0;
0562
0563
0564
0565 edm::ParameterSet cfgParSet_processes = cfg.getParameter<edm::ParameterSet>("processes");
0566 readCfgParameter<cfgEntryProcess>(cfgParSet_processes, processes_);
0567
0568
0569
0570
0571 int numProcesses_Data = 0;
0572 int numProcesses_sumMC = 0;
0573 for (std::map<std::string, cfgEntryProcess>::const_iterator process = processes_.begin(); process != processes_.end();
0574 ++process) {
0575 const std::string& type = process->second.type_;
0576
0577 if (!((type == type_smMC) || (type == type_bsmMC) || (type == type_smSumMC) || (type == type_Data))) {
0578 edm::LogError("TauDQMHistPlotter") << " Undefined process type = " << type << " !!";
0579 cfgError_ = 1;
0580 }
0581
0582 if (type == type_smSumMC)
0583 ++numProcesses_sumMC;
0584 if (type == type_Data)
0585 ++numProcesses_Data;
0586 }
0587
0588 if ((numProcesses_Data > 1) || (numProcesses_sumMC > 1)) {
0589 edm::LogError("TauDQMHistPlotter") << " Cannot have more than one process of types sumMC and Data !!";
0590 cfgError_ = 1;
0591 }
0592
0593
0594
0595 edm::ParameterSet cfgParSet_xAxes = cfg.getParameter<edm::ParameterSet>("xAxes");
0596 readCfgParameter<cfgEntryAxisX>(cfgParSet_xAxes, xAxes_);
0597
0598
0599
0600 edm::ParameterSet cfgParSet_yAxes = cfg.getParameter<edm::ParameterSet>("yAxes");
0601 readCfgParameter<cfgEntryAxisY>(cfgParSet_yAxes, yAxes_);
0602
0603
0604
0605 edm::ParameterSet cfgParSet_legends = cfg.getParameter<edm::ParameterSet>("legends");
0606 readCfgParameter<cfgEntryLegend>(cfgParSet_legends, legends_);
0607
0608
0609
0610 edm::ParameterSet cfgParSet_labels = cfg.getParameter<edm::ParameterSet>("labels");
0611 readCfgParameter<cfgEntryLabel>(cfgParSet_labels, labels_);
0612
0613
0614
0615 if (cfg.exists("drawOptionSets")) {
0616 edm::ParameterSet drawOptionSets = cfg.getParameter<edm::ParameterSet>("drawOptionSets");
0617 vstring drawOptionSetNames = drawOptionSets.getParameterNamesForType<edm::ParameterSet>();
0618 for (vstring::const_iterator drawOptionSetName = drawOptionSetNames.begin();
0619 drawOptionSetName != drawOptionSetNames.end();
0620 ++drawOptionSetName) {
0621 edm::ParameterSet drawOptionSet = drawOptionSets.getParameter<edm::ParameterSet>(*drawOptionSetName);
0622
0623 vstring drawOptionEntryNames = drawOptionSet.getParameterNamesForType<edm::ParameterSet>();
0624 for (vstring::const_iterator drawOptionEntryName = drawOptionEntryNames.begin();
0625 drawOptionEntryName != drawOptionEntryNames.end();
0626 ++drawOptionEntryName) {
0627 edm::ParameterSet drawOptionEntry = drawOptionSet.getParameter<edm::ParameterSet>(*drawOptionEntryName);
0628
0629 std::string drawOptionEntryName_full =
0630 std::string(*drawOptionSetName).append(drawOptionSeparator).append(*drawOptionEntryName);
0631 drawOptionEntries_.insert(std::pair<std::string, cfgEntryDrawOption>(
0632 drawOptionEntryName_full, cfgEntryDrawOption(drawOptionEntryName_full, drawOptionEntry)));
0633 }
0634 }
0635 }
0636
0637 if (cfg.exists("drawOptionEntries")) {
0638 edm::ParameterSet cfgParSet_drawOptionEntries = cfg.getParameter<edm::ParameterSet>("drawOptionEntries");
0639 readCfgParameter<cfgEntryDrawOption>(cfgParSet_drawOptionEntries, drawOptionEntries_);
0640 }
0641
0642
0643
0644 edm::ParameterSet drawJobs = cfg.getParameter<edm::ParameterSet>("drawJobs");
0645 vstring drawJobNames = drawJobs.getParameterNamesForType<edm::ParameterSet>();
0646 for (vstring::const_iterator drawJobName = drawJobNames.begin(); drawJobName != drawJobNames.end(); ++drawJobName) {
0647 edm::ParameterSet drawJob = drawJobs.getParameter<edm::ParameterSet>(*drawJobName);
0648
0649 std::map<int, plotDefList> plotDefMap;
0650
0651 if (drawJob.existsAs<edm::ParameterSet>("plots")) {
0652 edm::ParameterSet plots = drawJob.getParameter<edm::ParameterSet>("plots");
0653
0654 vstring dqmMonitorElements = plots.getParameter<vstring>("dqmMonitorElements");
0655 vstring processes = plots.getParameter<vstring>("processes");
0656
0657 std::string drawOptionSet = drawJob.getParameter<std::string>("drawOptionSet");
0658
0659
0660 vstring stack = (cfg.exists("stack")) ? drawJob.getParameter<vstring>("stack") : vstring();
0661
0662 for (vstring::const_iterator process = processes.begin(); process != processes.end(); ++process) {
0663 int index = 0;
0664 for (vstring::const_iterator dqmMonitorElement = dqmMonitorElements.begin();
0665 dqmMonitorElement != dqmMonitorElements.end();
0666 ++dqmMonitorElement) {
0667 bool stack_dqmMonitorElement = find_vstring(stack, *process);
0668 std::string drawOptionEntry = std::string(drawOptionSet).append(drawOptionSeparator).append(*process);
0669 plotDefMap[index].push_back(
0670 plotDefEntry(*dqmMonitorElement, drawOptionEntry, "", "", *process, stack_dqmMonitorElement));
0671 ++index;
0672 }
0673 }
0674 } else {
0675 typedef std::vector<edm::ParameterSet> vParameterSet;
0676 vParameterSet plots = drawJob.getParameter<vParameterSet>("plots");
0677
0678 std::string process = (drawJob.exists("process")) ? drawJob.getParameter<std::string>("process") : "";
0679
0680
0681 for (vParameterSet::const_iterator plot = plots.begin(); plot != plots.end(); ++plot) {
0682 if (process.empty() || plot->exists("process")) {
0683 process = plot->getParameter<std::string>("process");
0684
0685 }
0686
0687 std::string drawOptionEntry = plot->getParameter<std::string>("drawOptionEntry");
0688
0689
0690 std::string legendEntry = "", legendEntryErrorBand = "";
0691 if (plot->exists("legendEntry")) {
0692 legendEntry = plot->getParameter<std::string>("legendEntry");
0693 legendEntryErrorBand = (plot->exists("legendEntryErrorBand"))
0694 ? plot->getParameter<std::string>("legendEntryErrorBand")
0695 : std::string(legendEntry).append(" Uncertainty");
0696 }
0697
0698
0699
0700 vstring dqmMonitorElements = plot->getParameter<vstring>("dqmMonitorElements");
0701 int index = 0;
0702 for (vstring::const_iterator dqmMonitorElement = dqmMonitorElements.begin();
0703 dqmMonitorElement != dqmMonitorElements.end();
0704 ++dqmMonitorElement) {
0705 plotDefMap[index].push_back(
0706 plotDefEntry(*dqmMonitorElement, drawOptionEntry, legendEntry, legendEntryErrorBand, process, false));
0707 ++index;
0708 }
0709 }
0710 }
0711
0712
0713 unsigned numMonitorElements_ref = 0;
0714 bool isFirstEntry = true;
0715 for (std::map<int, plotDefList>::const_iterator plot = plotDefMap.begin(); plot != plotDefMap.end(); ++plot) {
0716 if (isFirstEntry) {
0717 numMonitorElements_ref = plot->second.size();
0718 isFirstEntry = false;
0719 } else {
0720 if (plot->second.size() != numMonitorElements_ref) {
0721 edm::LogError("TauDQMHistPlotter::TauDQMHistPlotter")
0722 << " Numbers of dqmMonitorElements must be the same for all plots"
0723 << " --> skipping drawJob = " << (*drawJobName) << " !!";
0724 cfgError_ = 1;
0725 }
0726 }
0727 }
0728
0729
0730 for (std::map<int, plotDefList>::iterator plot = plotDefMap.begin(); plot != plotDefMap.end(); ++plot) {
0731 for (plotDefList::iterator entry = plot->second.begin(); entry != plot->second.end(); ++entry) {
0732 std::string dqmMonitorElement = entry->dqmMonitorElement_;
0733 std::string process = entry->process_;
0734
0735 std::map<std::string, cfgEntryProcess>::const_iterator it = processes_.find(process);
0736 if (it != processes_.end()) {
0737 std::string process_dqmDirectory = it->second.dqmDirectory_;
0738
0739
0740
0741 int errorFlag = 0;
0742 std::string dqmMonitorElement_expanded =
0743 replace_string(dqmMonitorElement, processDirKeyword, process_dqmDirectory, 0, 1, errorFlag);
0744
0745
0746 if (!errorFlag) {
0747 entry->dqmMonitorElement_ = dqmMonitorElement_expanded;
0748 } else {
0749 cfgError_ = 1;
0750 }
0751 } else {
0752 edm::LogError("TauDQMHistPlotter::TauDQMHistPlotter") << " Undefined process = " << process << " !!";
0753 cfgError_ = 1;
0754 }
0755 }
0756 }
0757
0758 std::string title = (drawJob.exists("title")) ? drawJob.getParameter<std::string>("title") : "";
0759
0760 std::string xAxis = drawJob.getParameter<std::string>("xAxis");
0761 std::string yAxis = drawJob.getParameter<std::string>("yAxis");
0762
0763 std::string legend = drawJob.getParameter<std::string>("legend");
0764
0765 vstring labels = (drawJob.exists("labels")) ? drawJob.getParameter<vstring>("labels") : vstring();
0766
0767
0768
0769 for (std::map<int, plotDefList>::iterator plot = plotDefMap.begin(); plot != plotDefMap.end(); ++plot) {
0770 if (drawJob.exists("parameter")) {
0771 vstring vparameter = drawJob.getParameter<vstring>("parameter");
0772
0773
0774 for (vstring::const_iterator parameter = vparameter.begin(); parameter != vparameter.end(); ++parameter) {
0775 plotDefList plot_expanded;
0776
0777 for (plotDefList::const_iterator entry = plot->second.begin(); entry != plot->second.end(); ++entry) {
0778 std::string dqmMonitorElement = entry->dqmMonitorElement_;
0779
0780 int errorFlag = 0;
0781 std::string dqmMonitorElement_expanded =
0782 replace_string(dqmMonitorElement, parKeyword, *parameter, 1, 1, errorFlag);
0783
0784 if (!errorFlag) {
0785 plot_expanded.push_back(plotDefEntry(dqmMonitorElement_expanded,
0786 entry->drawOptionEntry_,
0787 entry->legendEntry_,
0788 entry->legendEntryErrorBand_,
0789 entry->process_,
0790 entry->doStack_));
0791 } else {
0792 cfgError_ = 1;
0793 }
0794 }
0795
0796 int errorFlag = 0;
0797 std::string title_expanded = replace_string(title, parKeyword, *parameter, 0, 1, errorFlag);
0798
0799 std::string xAxis_expanded = replace_string(xAxis, parKeyword, *parameter, 0, 1, errorFlag);
0800
0801 std::string yAxis_expanded = replace_string(yAxis, parKeyword, *parameter, 0, 1, errorFlag);
0802
0803 if (errorFlag)
0804 cfgError_ = 1;
0805
0806 drawJobs_.push_back(cfgEntryDrawJob(std::string(*drawJobName).append(*parameter),
0807 plot_expanded,
0808 title_expanded,
0809 xAxis_expanded,
0810 yAxis_expanded,
0811 legend,
0812 labels));
0813 }
0814 } else {
0815 drawJobs_.push_back(cfgEntryDrawJob(*drawJobName, plot->second, title, xAxis, yAxis, legend, labels));
0816 }
0817 }
0818 }
0819
0820
0821 for (std::list<cfgEntryDrawJob>::const_iterator drawJob = drawJobs_.begin(); drawJob != drawJobs_.end(); ++drawJob) {
0822 for (plotDefList::const_iterator plot = drawJob->plots_.begin(); plot != drawJob->plots_.end(); ++plot) {
0823 checkCfgDef<cfgEntryDrawOption>(
0824 plot->drawOptionEntry_, drawOptionEntries_, cfgError_, "drawOptionEntry", drawJob->name_);
0825 checkCfgDef<cfgEntryProcess>(plot->process_, processes_, cfgError_, "process", drawJob->name_);
0826 }
0827
0828 checkCfgDef<cfgEntryAxisX>(drawJob->xAxis_, xAxes_, cfgError_, "xAxis", drawJob->name_);
0829 checkCfgDef<cfgEntryAxisY>(drawJob->yAxis_, yAxes_, cfgError_, "yAxis", drawJob->name_);
0830
0831 checkCfgDef<cfgEntryLegend>(drawJob->legend_, legends_, cfgError_, "legend", drawJob->name_);
0832
0833 checkCfgDefs<cfgEntryLabel>(drawJob->labels_, labels_, cfgError_, "label", drawJob->name_);
0834 }
0835
0836
0837
0838 canvasSizeX_ = (cfg.exists("canvasSizeX")) ? cfg.getParameter<int>("canvasSizeX") : defaultCanvasSizeX;
0839 canvasSizeY_ = (cfg.exists("canvasSizeY")) ? cfg.getParameter<int>("canvasSizeY") : defaultCanvasSizeY;
0840
0841
0842
0843
0844 outputFilePath_ = (cfg.exists("outputFilePath")) ? cfg.getParameter<std::string>("outputFilePath") : "";
0845 if (outputFilePath_.rbegin() != outputFilePath_.rend()) {
0846 if ((*outputFilePath_.rbegin()) == '/')
0847 outputFilePath_.erase(outputFilePath_.length() - 1);
0848 }
0849
0850
0851 outputFileName_ = (cfg.exists("outputFileName")) ? cfg.getParameter<std::string>("outputFileName") : "";
0852
0853
0854 indOutputFileName_ = (cfg.exists("indOutputFileName")) ? cfg.getParameter<std::string>("indOutputFileName") : "";
0855 if (!indOutputFileName_.empty() && indOutputFileName_.find('.') == std::string::npos) {
0856 edm::LogError("TauDQMHistPlotter") << " Failed to determine type of graphics format from indOutputFileName = "
0857 << indOutputFileName_ << " !!";
0858 cfgError_ = 1;
0859 }
0860
0861
0862
0863
0864
0865
0866
0867 if (outputFileName_.empty() && indOutputFileName_.empty()) {
0868 edm::LogError("TauDQMHistPlotter") << " Either outputFileName or indOutputFileName must be specified !!";
0869 cfgError_ = 1;
0870 }
0871
0872 if (!outputFileName_.empty() && !indOutputFileName_.empty()) {
0873 edm::LogError("TauDQMHistPlotter") << " Must not specify outputFileName and indOutputFileName simultaneously !!";
0874 cfgError_ = 1;
0875 }
0876
0877 if (verbosity)
0878 std::cout << "done." << std::endl;
0879 }
0880
0881 TauDQMHistPlotter::~TauDQMHistPlotter() {
0882
0883 }
0884
0885 void TauDQMHistPlotter::analyze(const edm::Event&, const edm::EventSetup&) {
0886
0887 }
0888
0889 void TauDQMHistPlotter::endRun(const edm::Run& r, const edm::EventSetup& c) {
0890 if (verbosity)
0891 std::cout << "<TauDQMHistPlotter::endJob>:" << std::endl;
0892
0893
0894 if (cfgError_) {
0895 edm::LogError("endJob") << " Error in Configuration ParameterSet --> histograms will NOT be plotted !!";
0896 return;
0897 }
0898
0899
0900 if (!edm::Service<DQMStore>().isAvailable()) {
0901 edm::LogError("endJob") << " Failed to access dqmStore --> histograms will NOT be plotted !!";
0902 return;
0903 }
0904
0905 DQMStore& dqmStore = (*edm::Service<DQMStore>());
0906
0907
0908
0909
0910
0911
0912 gROOT->SetBatch(true);
0913
0914
0915
0916 TCanvas canvas("TauDQMHistPlotter", "TauDQMHistPlotter", canvasSizeX_, canvasSizeY_);
0917 canvas.SetFillColor(10);
0918
0919
0920
0921
0922
0923
0924
0925
0926
0927 TPostScript* ps = nullptr;
0928 if (!outputFileName_.empty()) {
0929 std::string psFileName =
0930 (!outputFilePath_.empty()) ? std::string(outputFilePath_).append("/").append(outputFileName_) : outputFileName_;
0931 ps = new TPostScript(psFileName.data(), 112);
0932 }
0933
0934
0935 for (std::list<cfgEntryDrawJob>::const_iterator drawJob = drawJobs_.begin(); drawJob != drawJobs_.end(); ++drawJob) {
0936 const std::string& drawJobName = drawJob->name_;
0937 if (verbosity)
0938 std::cout << "--> processing drawJob " << drawJobName << "..." << std::endl;
0939
0940
0941 TH1* stackedHistogram_sum = nullptr;
0942 std::list<TH1*> histogramsToDelete;
0943 std::list<plotDefEntry*> drawOptionsToDelete;
0944
0945 typedef std::pair<TH1*, const plotDefEntry*> histogram_drawOption_pair;
0946 std::list<histogram_drawOption_pair> allHistograms;
0947
0948 for (plotDefList::const_iterator plot = drawJob->plots_.begin(); plot != drawJob->plots_.end(); ++plot) {
0949 std::string dqmMonitorElementName_full =
0950 dqmDirectoryName(std::string(dqmRootDirectory)).append(plot->dqmMonitorElement_);
0951 if (verbosity)
0952 std::cout << " dqmMonitorElementName_full = " << dqmMonitorElementName_full << std::endl;
0953 MonitorElement* dqmMonitorElement = dqmStore.get(dqmMonitorElementName_full);
0954
0955 TH1* histogram = dqmMonitorElement->getTH1F();
0956 if (verbosity)
0957 std::cout << "Got Histogram " << std::endl;
0958
0959
0960
0961 if (histogram == nullptr) {
0962 edm::LogError("endJob") << " Failed to access dqmMonitorElement = " << dqmMonitorElementName_full << ","
0963 << " needed by drawJob = " << drawJobName << " --> histograms will NOT be plotted !!";
0964 continue;
0965 }
0966
0967 if (!histogram->GetSumw2N())
0968 histogram->Sumw2();
0969
0970 const cfgEntryDrawOption* drawOptionConfig =
0971 findCfgDef<cfgEntryDrawOption>(plot->drawOptionEntry_, drawOptionEntries_, "drawOptionEntry", drawJobName);
0972 if (drawOptionConfig == nullptr) {
0973 edm::LogError("endJob") << " Failed to access information needed by drawJob = " << drawJobName
0974 << " --> histograms will NOT be plotted !!";
0975 return;
0976 }
0977
0978 if (drawOptionConfig->drawOption_ == drawOption_eBand) {
0979
0980 TH1* histogram_centralValue = dynamic_cast<TH1*>(histogram->Clone());
0981 histogram_centralValue->SetName(std::string(histogram->GetName()).append("_centralValue").data());
0982 cfgEntryDrawOption drawOptionConfig_centralValue(*drawOptionConfig);
0983 drawOptionConfig_centralValue.fillColor_ = 0;
0984 drawOptionConfig_centralValue.fillStyle_ = 0;
0985 drawOptionConfig_centralValue.drawOption_ = "hist";
0986 drawOptionConfig_centralValue.drawOptionLegend_ = "l";
0987 std::string drawOptionName_centralValue = std::string(plot->drawOptionEntry_).append("_centralValue");
0988
0989
0990 if (drawOptionEntries_.find(drawOptionName_centralValue) == drawOptionEntries_.end())
0991 drawOptionEntries_.insert(std::pair<std::string, cfgEntryDrawOption>(
0992 drawOptionName_centralValue,
0993 cfgEntryDrawOption(drawOptionName_centralValue, drawOptionConfig_centralValue)));
0994 plotDefEntry* plot_centralValue = new plotDefEntry(*plot);
0995 plot_centralValue->drawOptionEntry_ = drawOptionName_centralValue;
0996 allHistograms.push_back(histogram_drawOption_pair(histogram_centralValue, plot_centralValue));
0997 histogramsToDelete.push_back(histogram_centralValue);
0998 drawOptionsToDelete.push_back(plot_centralValue);
0999
1000
1001 TH1* histogram_ErrorBand = dynamic_cast<TH1*>(histogram->Clone());
1002 histogram_ErrorBand->SetName(std::string(histogram->GetName()).append("_ErrorBand").data());
1003 cfgEntryDrawOption drawOptionConfig_ErrorBand(*drawOptionConfig);
1004 drawOptionConfig_ErrorBand.markerColor_ = drawOptionConfig_ErrorBand.fillColor_;
1005 drawOptionConfig_ErrorBand.markerSize_ = 0.;
1006 drawOptionConfig_ErrorBand.lineColor_ = drawOptionConfig_ErrorBand.fillColor_;
1007 drawOptionConfig_ErrorBand.lineWidth_ = 0;
1008 drawOptionConfig_ErrorBand.drawOption_ = "e2";
1009 drawOptionConfig_ErrorBand.drawOptionLegend_ = "f";
1010 std::string drawOptionName_ErrorBand = std::string(plot->drawOptionEntry_).append("_ErrorBand");
1011
1012
1013 if (drawOptionEntries_.find(drawOptionName_ErrorBand) == drawOptionEntries_.end())
1014 drawOptionEntries_.insert(std::pair<std::string, cfgEntryDrawOption>(
1015 drawOptionName_ErrorBand, cfgEntryDrawOption(drawOptionName_ErrorBand, drawOptionConfig_ErrorBand)));
1016 plotDefEntry* plot_ErrorBand = new plotDefEntry(*plot);
1017 plot_ErrorBand->drawOptionEntry_ = drawOptionName_ErrorBand;
1018 plot_ErrorBand->isErrorBand_ = true;
1019 allHistograms.push_back(histogram_drawOption_pair(histogram_ErrorBand, plot_ErrorBand));
1020 histogramsToDelete.push_back(histogram_ErrorBand);
1021 drawOptionsToDelete.push_back(plot_ErrorBand);
1022 } else if (plot->doStack_) {
1023 TH1* stackedHistogram = dynamic_cast<TH1*>(histogram->Clone());
1024 if (stackedHistogram_sum)
1025 stackedHistogram->Add(stackedHistogram_sum);
1026 stackedHistogram_sum = stackedHistogram;
1027 histogramsToDelete.push_back(stackedHistogram);
1028 allHistograms.push_back(histogram_drawOption_pair(stackedHistogram, &(*plot)));
1029 } else {
1030 allHistograms.push_back(histogram_drawOption_pair(histogram, &(*plot)));
1031 }
1032 }
1033
1034
1035
1036 double yAxisNorm = 0.;
1037 for (std::list<histogram_drawOption_pair>::const_iterator it = allHistograms.begin(); it != allHistograms.end();
1038 ++it) {
1039 yAxisNorm = TMath::Max(yAxisNorm, it->first->GetMaximum());
1040 }
1041
1042
1043
1044 const cfgEntryAxisX* xAxisConfig = findCfgDef<cfgEntryAxisX>(drawJob->xAxis_, xAxes_, "xAxis", drawJobName);
1045 const cfgEntryAxisY* yAxisConfig = findCfgDef<cfgEntryAxisY>(drawJob->yAxis_, yAxes_, "yAxis", drawJobName);
1046 const cfgEntryLegend* legendConfig = findCfgDef<cfgEntryLegend>(drawJob->legend_, legends_, "legend", drawJobName);
1047 if (xAxisConfig == nullptr || yAxisConfig == nullptr || legendConfig == nullptr) {
1048 edm::LogError("endJob") << " Failed to access information needed by drawJob = " << drawJobName
1049 << " --> histograms will NOT be plotted !!";
1050 return;
1051 }
1052
1053
1054
1055
1056 TLegend legend(defaultLegendPosX,
1057 defaultLegendPosY,
1058 defaultLegendPosX + defaultLegendSizeX,
1059 defaultLegendPosY + defaultLegendSizeY);
1060 legendConfig->applyTo(&legend);
1061
1062 std::list<histoDrawEntry> smProcessHistogramList;
1063 std::list<histoDrawEntry> bsmProcessHistogramList;
1064 std::list<histoDrawEntry> smSumHistogramList;
1065 std::list<histoDrawEntry> smSumUncertaintyHistogramList;
1066 std::list<histoDrawEntry> dataHistogramList;
1067
1068 for (std::list<histogram_drawOption_pair>::const_iterator it = allHistograms.begin(); it != allHistograms.end();
1069 ++it) {
1070 TH1* histogram = it->first;
1071 const plotDefEntry* drawOption = it->second;
1072
1073 const cfgEntryDrawOption* drawOptionConfig = findCfgDef<cfgEntryDrawOption>(
1074 drawOption->drawOptionEntry_, drawOptionEntries_, "drawOptionEntry", drawJobName);
1075 const cfgEntryProcess* processConfig =
1076 findCfgDef<cfgEntryProcess>(drawOption->process_, processes_, "process", drawJobName);
1077 if (drawOptionConfig == nullptr || processConfig == nullptr) {
1078 edm::LogError("endJob") << " Failed to access information needed by drawJob = " << drawJobName
1079 << " --> histograms will NOT be plotted !!";
1080 return;
1081 }
1082
1083 if (!drawJob->title_.empty())
1084 histogram->SetTitle(drawJob->title_.data());
1085
1086 xAxisConfig->applyTo(histogram);
1087 yAxisConfig->applyTo(histogram, yAxisNorm);
1088
1089 bool yLogScale = (yAxisConfig->yScale_ == yScale_log) ? true : false;
1090
1091
1092 canvas.SetLogy(yLogScale);
1093
1094 drawOptionConfig->applyTo(histogram);
1095 histogram->SetStats(false);
1096
1097 if (drawOption->isErrorBand_) {
1098 smSumUncertaintyHistogramList.push_back(histoDrawEntry(histogram, drawOptionConfig->drawOption_.data()));
1099 } else {
1100 if (processConfig->type_ == type_smMC) {
1101 smProcessHistogramList.push_back(histoDrawEntry(histogram, drawOptionConfig->drawOption_.data()));
1102 } else if (processConfig->type_ == type_bsmMC) {
1103 bsmProcessHistogramList.push_back(histoDrawEntry(histogram, drawOptionConfig->drawOption_.data()));
1104 } else if (processConfig->type_ == type_smSumMC) {
1105 smSumHistogramList.push_back(histoDrawEntry(histogram, drawOptionConfig->drawOption_.data()));
1106 } else if (processConfig->type_ == type_Data) {
1107 dataHistogramList.push_back(histoDrawEntry(histogram, drawOptionConfig->drawOption_.data()));
1108 }
1109 }
1110
1111 std::string legendEntry, legendDrawOption;
1112 if (drawOption->isErrorBand_) {
1113 legendEntry = (!drawOption->legendEntryErrorBand_.empty()) ? drawOption->legendEntryErrorBand_
1114 : processConfig->legendEntryErrorBand_;
1115 legendDrawOption = "f";
1116 } else {
1117 legendEntry = (!drawOption->legendEntry_.empty()) ? drawOption->legendEntry_ : processConfig->legendEntry_;
1118 legendDrawOption = drawOptionConfig->drawOptionLegend_;
1119 }
1120
1121 legend.AddEntry(histogram, legendEntry.data(), legendDrawOption.data());
1122 }
1123
1124 std::list<TPaveText> labels;
1125 for (vstring::const_iterator labelName = drawJob->labels_.begin(); labelName != drawJob->labels_.end();
1126 ++labelName) {
1127 const cfgEntryLabel* labelConfig = findCfgDef<cfgEntryLabel>(*labelName, labels_, "label", drawJobName);
1128
1129 TPaveText label;
1130 labelConfig->applyTo(&label);
1131
1132 labels.push_back(label);
1133 }
1134
1135
1136
1137
1138
1139
1140
1141
1142 bool isFirstHistogram = true;
1143 drawHistograms(smSumUncertaintyHistogramList, isFirstHistogram);
1144 drawHistograms(smSumHistogramList, isFirstHistogram);
1145
1146
1147
1148 for (std::list<histoDrawEntry>::reverse_iterator it = smProcessHistogramList.rbegin();
1149 it != smProcessHistogramList.rend();
1150 ++it) {
1151 std::string drawOption = (isFirstHistogram) ? it->second : std::string(it->second).append("same");
1152 it->first->Draw(drawOption.data());
1153 isFirstHistogram = false;
1154 }
1155
1156 drawHistograms(bsmProcessHistogramList, isFirstHistogram);
1157 drawHistograms(dataHistogramList, isFirstHistogram);
1158
1159 legend.Draw();
1160
1161 for (std::list<TPaveText>::iterator label = labels.begin(); label != labels.end(); ++label) {
1162 label->Draw();
1163 }
1164
1165
1166
1167 canvas.Update();
1168
1169
1170 if (!indOutputFileName_.empty() && toFile_) {
1171 int errorFlag = 0;
1172 std::string modIndOutputFileName = replace_string(indOutputFileName_, plotKeyword, drawJobName, 1, 1, errorFlag);
1173 if (!errorFlag) {
1174 std::string fullFileName = (!outputFilePath_.empty())
1175 ? std::string(outputFilePath_).append("/").append(modIndOutputFileName)
1176 : modIndOutputFileName;
1177 canvas.Print(fullFileName.data());
1178 } else {
1179 edm::LogError("endJob") << " Failed to decode indOutputFileName = " << indOutputFileName_ << " --> skipping !!";
1180 }
1181 }
1182
1183 if (ps)
1184 ps->NewPage();
1185
1186
1187 for (std::list<TH1*>::const_iterator histogram = histogramsToDelete.begin(); histogram != histogramsToDelete.end();
1188 ++histogram) {
1189 delete (*histogram);
1190 }
1191
1192 for (std::list<plotDefEntry*>::const_iterator drawOption = drawOptionsToDelete.begin();
1193 drawOption != drawOptionsToDelete.end();
1194 ++drawOption) {
1195 delete (*drawOption);
1196 }
1197 }
1198
1199
1200 canvas.Clear();
1201 if (verbosity)
1202 std::cout << "done." << std::endl;
1203 if (ps)
1204 ps->Close();
1205 delete ps;
1206 }
1207
1208 #include "FWCore/Framework/interface/MakerMacros.h"
1209
1210 DEFINE_FWK_MODULE(TauDQMHistPlotter);