#include <DQMHistPlotter.h>

Inheritance diagram for TauDQMHistPlotter:

Classes
struct	cfgEntryAxisX

struct	cfgEntryAxisY

struct	cfgEntryDrawJob

struct	cfgEntryDrawOption

struct	cfgEntryLabel

struct	cfgEntryLegend

struct	cfgEntryProcess

struct	plotDefEntry

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	endRun (const edm::Run &r, const edm::EventSetup &c) override

	TauDQMHistPlotter (const edm::ParameterSet &)

	~TauDQMHistPlotter () override

Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector < ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Types
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

typedef std::list< plotDefEntry >	plotDefList

typedef std::vector< std::string >	vstring

Private Attributes
int	canvasSizeX_

int	canvasSizeY_

int	cfgError_

std::list< cfgEntryDrawJob >	drawJobs_

std::map< std::string, cfgEntryDrawOption >	drawOptionEntries_

std::string	indOutputFileName_

std::map< std::string, cfgEntryLabel >	labels_

std::map< std::string, cfgEntryLegend >	legends_

std::string	outputFileName_

std::string	outputFilePath_

std::map< std::string, cfgEntryProcess >	processes_

bool	toFile_

std::map< std::string, cfgEntryAxisX >	xAxes_

std::map< std::string, cfgEntryAxisY >	yAxes_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Class to plot histograms and create a postscript file

Author: Christian Veelken, UC Davis

Definition at line 27 of file DQMHistPlotter.h.

Member Typedef Documentation

typedef dqm::legacy::DQMStore TauDQMHistPlotter::DQMStore

private

Definition at line 28 of file DQMHistPlotter.h.

typedef dqm::legacy::MonitorElement TauDQMHistPlotter::MonitorElement

private

Definition at line 29 of file DQMHistPlotter.h.

typedef std::list<plotDefEntry> TauDQMHistPlotter::plotDefList

private

Definition at line 136 of file DQMHistPlotter.h.

typedef std::vector<std::string> TauDQMHistPlotter::vstring

private

Definition at line 31 of file DQMHistPlotter.h.

Constructor & Destructor Documentation

TauDQMHistPlotter::TauDQMHistPlotter ( const edm::ParameterSet & cfg )

explicit

Definition at line 556 of file DQMHistPlotter.cc.

References canvasSizeX_, canvasSizeY_, cfgError_, gather_cfg::cout, defaultCanvasSizeX, defaultCanvasSizeY, drawJobs_, drawOptionEntries_, drawOptionSeparator, mps_splice::entry, edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), find_vstring(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNamesForType(), indOutputFileName_, HLT_FULL_cff::labels, labels_, legends_, outputFileName_, outputFilePath_, parKeyword, bigModule::plot(), L1TEGammaDiff_cfi::plots, LaserDQM_cfg::process, processDirKeyword, parallelization::processes, processes_, replace_string(), svgfig::stack, AlCaHLTBitMon_QueryRunRegistry::string, runGCPTkAlMap::title, toFile_, type_bsmMC, type_Data, type_smMC, type_smSumMC, HLT_FULL_cff::verbosity, xAxes_, and yAxes_.

                                                                {
   if (verbosity)
     std::cout << "<TauDQMHistPlotter::TauDQMHistPlotter>:" << std::endl;
 
   toFile_ = cfg.getParameter<bool>("PrintToFile");
   cfgError_ = 0;
 
   //--- configure processes
   //std::cout << "--> configuring processes..." << std::endl;
   edm::ParameterSet cfgParSet_processes = cfg.getParameter<edm::ParameterSet>("processes");
   readCfgParameter<cfgEntryProcess>(cfgParSet_processes, processes_);
 
   //--- check that process types are defined
   //std::cout << "--> checking configuration parameters..." << std::endl;
 
   int numProcesses_Data = 0;
   int numProcesses_sumMC = 0;
   for (std::map<std::string, cfgEntryProcess>::const_iterator process = processes_.begin(); process != processes_.end();
        ++process) {
     const std::string& type = process->second.type_;
 
     if (!((type == type_smMC) || (type == type_bsmMC) || (type == type_smSumMC) || (type == type_Data))) {
       edm::LogError("TauDQMHistPlotter") << " Undefined process type = " << type << " !!";
       cfgError_ = 1;
     }
 
     if (type == type_smSumMC)
       ++numProcesses_sumMC;
     if (type == type_Data)
       ++numProcesses_Data;
   }
 
   if ((numProcesses_Data > 1) || (numProcesses_sumMC > 1)) {
     edm::LogError("TauDQMHistPlotter") << " Cannot have more than one process of types sumMC and Data !!";
     cfgError_ = 1;
   }
 
   //--- configure x-axes
   //std::cout << "--> configuring x-axes..." << std::endl;
   edm::ParameterSet cfgParSet_xAxes = cfg.getParameter<edm::ParameterSet>("xAxes");
   readCfgParameter<cfgEntryAxisX>(cfgParSet_xAxes, xAxes_);
 
   //--- configure y-axes
   //std::cout << "--> configuring y-axes..." << std::endl;
   edm::ParameterSet cfgParSet_yAxes = cfg.getParameter<edm::ParameterSet>("yAxes");
   readCfgParameter<cfgEntryAxisY>(cfgParSet_yAxes, yAxes_);
 
   //--- configure legends
   //std::cout << "--> configuring legends..." << std::endl;
   edm::ParameterSet cfgParSet_legends = cfg.getParameter<edm::ParameterSet>("legends");
   readCfgParameter<cfgEntryLegend>(cfgParSet_legends, legends_);
 
   //--- configure labels
   //std::cout << "--> configuring labels..." << std::endl;
   edm::ParameterSet cfgParSet_labels = cfg.getParameter<edm::ParameterSet>("labels");
   readCfgParameter<cfgEntryLabel>(cfgParSet_labels, labels_);
 
   //--- configure drawOptions
   //std::cout << "--> configuring drawOptions..." << std::endl;
   if (cfg.exists("drawOptionSets")) {
     edm::ParameterSet drawOptionSets = cfg.getParameter<edm::ParameterSet>("drawOptionSets");
     vstring drawOptionSetNames = drawOptionSets.getParameterNamesForType<edm::ParameterSet>();
     for (vstring::const_iterator drawOptionSetName = drawOptionSetNames.begin();
          drawOptionSetName != drawOptionSetNames.end();
          ++drawOptionSetName) {
       edm::ParameterSet drawOptionSet = drawOptionSets.getParameter<edm::ParameterSet>(*drawOptionSetName);
 
       vstring drawOptionEntryNames = drawOptionSet.getParameterNamesForType<edm::ParameterSet>();
       for (vstring::const_iterator drawOptionEntryName = drawOptionEntryNames.begin();
            drawOptionEntryName != drawOptionEntryNames.end();
            ++drawOptionEntryName) {
         edm::ParameterSet drawOptionEntry = drawOptionSet.getParameter<edm::ParameterSet>(*drawOptionEntryName);
 
         std::string drawOptionEntryName_full =
             std::string(*drawOptionSetName).append(drawOptionSeparator).append(*drawOptionEntryName);
         drawOptionEntries_.insert(std::pair<std::string, cfgEntryDrawOption>(
             drawOptionEntryName_full, cfgEntryDrawOption(drawOptionEntryName_full, drawOptionEntry)));
       }
     }
   }
 
   if (cfg.exists("drawOptionEntries")) {
     edm::ParameterSet cfgParSet_drawOptionEntries = cfg.getParameter<edm::ParameterSet>("drawOptionEntries");
     readCfgParameter<cfgEntryDrawOption>(cfgParSet_drawOptionEntries, drawOptionEntries_);
   }
 
   //--- configure drawJobs
   //std::cout << "--> configuring drawJobs..." << std::endl;
   edm::ParameterSet drawJobs = cfg.getParameter<edm::ParameterSet>("drawJobs");
   vstring drawJobNames = drawJobs.getParameterNamesForType<edm::ParameterSet>();
   for (vstring::const_iterator drawJobName = drawJobNames.begin(); drawJobName != drawJobNames.end(); ++drawJobName) {
     edm::ParameterSet drawJob = drawJobs.getParameter<edm::ParameterSet>(*drawJobName);
 
     std::map<int, plotDefList> plotDefMap;
 
     if (drawJob.existsAs<edm::ParameterSet>("plots")) {  // display same monitor element for different processes
       edm::ParameterSet plots = drawJob.getParameter<edm::ParameterSet>("plots");
 
       vstring dqmMonitorElements = plots.getParameter<vstring>("dqmMonitorElements");
       vstring processes = plots.getParameter<vstring>("processes");
 
       std::string drawOptionSet = drawJob.getParameter<std::string>("drawOptionSet");
       //std::cout << "drawOptionSet = " << drawOptionSet << std::endl;
 
       vstring stack = (cfg.exists("stack")) ? drawJob.getParameter<vstring>("stack") : vstring();
 
       for (vstring::const_iterator process = processes.begin(); process != processes.end(); ++process) {
         int index = 0;
         for (vstring::const_iterator dqmMonitorElement = dqmMonitorElements.begin();
              dqmMonitorElement != dqmMonitorElements.end();
              ++dqmMonitorElement) {
           bool stack_dqmMonitorElement = find_vstring(stack, *process);
           std::string drawOptionEntry = std::string(drawOptionSet).append(drawOptionSeparator).append(*process);
           plotDefMap[index].push_back(
               plotDefEntry(*dqmMonitorElement, drawOptionEntry, "", "", *process, stack_dqmMonitorElement));
           ++index;
         }
       }
     } else {  // display different monitor elements for same process
       typedef std::vector<edm::ParameterSet> vParameterSet;
       vParameterSet plots = drawJob.getParameter<vParameterSet>("plots");
 
       std::string process = (drawJob.exists("process")) ? drawJob.getParameter<std::string>("process") : "";
       //std::cout << "process (globally set) = " << process << std::endl;
 
       for (vParameterSet::const_iterator plot = plots.begin(); plot != plots.end(); ++plot) {
         if (process.empty() || plot->exists("process")) {
           process = plot->getParameter<std::string>("process");
           //std::cout << "process (locally set) = " << process << std::endl;
         }
 
         std::string drawOptionEntry = plot->getParameter<std::string>("drawOptionEntry");
         //std::cout << "drawOptionEntry = " << drawOptionEntry << std::endl;
 
         std::string legendEntry = "", legendEntryErrorBand = "";
         if (plot->exists("legendEntry")) {
           legendEntry = plot->getParameter<std::string>("legendEntry");
           legendEntryErrorBand = (plot->exists("legendEntryErrorBand"))
                                      ? plot->getParameter<std::string>("legendEntryErrorBand")
                                      : std::string(legendEntry).append(" Uncertainty");
         }
         //std::cout << "legendEntry = " << legendEntry << std::endl;
         //std::cout << "legendEntryErrorBand = " << legendEntryErrorBand << std::endl;
 
         vstring dqmMonitorElements = plot->getParameter<vstring>("dqmMonitorElements");
         int index = 0;
         for (vstring::const_iterator dqmMonitorElement = dqmMonitorElements.begin();
              dqmMonitorElement != dqmMonitorElements.end();
              ++dqmMonitorElement) {
           plotDefMap[index].push_back(
               plotDefEntry(*dqmMonitorElement, drawOptionEntry, legendEntry, legendEntryErrorBand, process, false));
           ++index;
         }
       }
     }
 
     //--- check that number of displayed monitor elements is the same for each plot
     unsigned numMonitorElements_ref = 0;
     bool isFirstEntry = true;
     for (std::map<int, plotDefList>::const_iterator plot = plotDefMap.begin(); plot != plotDefMap.end(); ++plot) {
       if (isFirstEntry) {
         numMonitorElements_ref = plot->second.size();
         isFirstEntry = false;
       } else {
         if (plot->second.size() != numMonitorElements_ref) {
           edm::LogError("TauDQMHistPlotter::TauDQMHistPlotter")
               << " Numbers of dqmMonitorElements must be the same for all plots"
               << " --> skipping drawJob = " << (*drawJobName) << " !!";
           cfgError_ = 1;
         }
       }
     }
 
     //--- expand process directories in names of dqmMonitorElements
     for (std::map<int, plotDefList>::iterator plot = plotDefMap.begin(); plot != plotDefMap.end(); ++plot) {
       for (plotDefList::iterator entry = plot->second.begin(); entry != plot->second.end(); ++entry) {
         std::string dqmMonitorElement = entry->dqmMonitorElement_;
         std::string process = entry->process_;
 
         std::map<std::string, cfgEntryProcess>::const_iterator it = processes_.find(process);
         if (it != processes_.end()) {
           std::string process_dqmDirectory = it->second.dqmDirectory_;
 
           //std::cout << "replacing processDir = " << process_dqmDirectory << " in drawJob = " << (*drawJobName) << std::endl;
 
           int errorFlag = 0;
           std::string dqmMonitorElement_expanded =
               replace_string(dqmMonitorElement, processDirKeyword, process_dqmDirectory, 0, 1, errorFlag);
           //std::cout << " dqmMonitorElement_expanded = " << dqmMonitorElement_expanded << std::endl;
 
           if (!errorFlag) {
             entry->dqmMonitorElement_ = dqmMonitorElement_expanded;
           } else {
             cfgError_ = 1;
           }
         } else {
           edm::LogError("TauDQMHistPlotter::TauDQMHistPlotter") << " Undefined process = " << process << " !!";
           cfgError_ = 1;
         }
       }
     }
 
     std::string title = (drawJob.exists("title")) ? drawJob.getParameter<std::string>("title") : "";
 
     std::string xAxis = drawJob.getParameter<std::string>("xAxis");
     std::string yAxis = drawJob.getParameter<std::string>("yAxis");
 
     std::string legend = drawJob.getParameter<std::string>("legend");
 
     vstring labels = (drawJob.exists("labels")) ? drawJob.getParameter<vstring>("labels") : vstring();
 
     //--- expand parameters in names of dqmMonitorElements;
     //    create drawJob objects
     for (std::map<int, plotDefList>::iterator plot = plotDefMap.begin(); plot != plotDefMap.end(); ++plot) {
       if (drawJob.exists("parameter")) {
         vstring vparameter = drawJob.getParameter<vstring>("parameter");
         //std::cout << "replacing parameter = " << format_vstring(vparameter) << " in drawJob = " << (*drawJobName) << std::endl;
 
         for (vstring::const_iterator parameter = vparameter.begin(); parameter != vparameter.end(); ++parameter) {
           plotDefList plot_expanded;
 
           for (plotDefList::const_iterator entry = plot->second.begin(); entry != plot->second.end(); ++entry) {
             std::string dqmMonitorElement = entry->dqmMonitorElement_;
 
             int errorFlag = 0;
             std::string dqmMonitorElement_expanded =
                 replace_string(dqmMonitorElement, parKeyword, *parameter, 1, 1, errorFlag);
             //std::cout << " dqmMonitorElement_expanded = " << dqmMonitorElement_expanded << std::endl;
             if (!errorFlag) {
               plot_expanded.push_back(plotDefEntry(dqmMonitorElement_expanded,
                                                    entry->drawOptionEntry_,
                                                    entry->legendEntry_,
                                                    entry->legendEntryErrorBand_,
                                                    entry->process_,
                                                    entry->doStack_));
             } else {
               cfgError_ = 1;
             }
           }
 
           int errorFlag = 0;
           std::string title_expanded = replace_string(title, parKeyword, *parameter, 0, 1, errorFlag);
           //std::cout << " title_expanded = " << title_expanded << std::endl;
           std::string xAxis_expanded = replace_string(xAxis, parKeyword, *parameter, 0, 1, errorFlag);
           //std::cout << " xAxis_expanded = " << xAxis_expanded << std::endl;
           std::string yAxis_expanded = replace_string(yAxis, parKeyword, *parameter, 0, 1, errorFlag);
           //std::cout << " yAxis_expanded = " << yAxis_expanded << std::endl;
           if (errorFlag)
             cfgError_ = 1;
 
           drawJobs_.push_back(cfgEntryDrawJob(std::string(*drawJobName).append(*parameter),
                                               plot_expanded,
                                               title_expanded,
                                               xAxis_expanded,
                                               yAxis_expanded,
                                               legend,
                                               labels));
         }
       } else {
         drawJobs_.push_back(cfgEntryDrawJob(*drawJobName, plot->second, title, xAxis, yAxis, legend, labels));
       }
     }
   }
 
   //--- check that all information neccessary to process drawJob is defined;
   for (std::list<cfgEntryDrawJob>::const_iterator drawJob = drawJobs_.begin(); drawJob != drawJobs_.end(); ++drawJob) {
     for (plotDefList::const_iterator plot = drawJob->plots_.begin(); plot != drawJob->plots_.end(); ++plot) {
       checkCfgDef<cfgEntryDrawOption>(
           plot->drawOptionEntry_, drawOptionEntries_, cfgError_, "drawOptionEntry", drawJob->name_);
       checkCfgDef<cfgEntryProcess>(plot->process_, processes_, cfgError_, "process", drawJob->name_);
     }
 
     checkCfgDef<cfgEntryAxisX>(drawJob->xAxis_, xAxes_, cfgError_, "xAxis", drawJob->name_);
     checkCfgDef<cfgEntryAxisY>(drawJob->yAxis_, yAxes_, cfgError_, "yAxis", drawJob->name_);
 
     checkCfgDef<cfgEntryLegend>(drawJob->legend_, legends_, cfgError_, "legend", drawJob->name_);
 
     checkCfgDefs<cfgEntryLabel>(drawJob->labels_, labels_, cfgError_, "label", drawJob->name_);
   }
 
   //--- configure canvas size
   //std::cout << "--> configuring canvas size..." << std::endl;
   canvasSizeX_ = (cfg.exists("canvasSizeX")) ? cfg.getParameter<int>("canvasSizeX") : defaultCanvasSizeX;
   canvasSizeY_ = (cfg.exists("canvasSizeY")) ? cfg.getParameter<int>("canvasSizeY") : defaultCanvasSizeY;
 
   //--- configure output files
   //std::cout << "--> configuring postscript output file..." << std::endl;
 
   outputFilePath_ = (cfg.exists("outputFilePath")) ? cfg.getParameter<std::string>("outputFilePath") : "";
   if (outputFilePath_.rbegin() != outputFilePath_.rend()) {
     if ((*outputFilePath_.rbegin()) == '/')
       outputFilePath_.erase(outputFilePath_.length() - 1);
   }
   //std::cout << " outputFilePath = " << outputFilePath_ << std::endl;
 
   outputFileName_ = (cfg.exists("outputFileName")) ? cfg.getParameter<std::string>("outputFileName") : "";
   //std::cout << " outputFileName = " << outputFileName_ << std::endl;
 
   indOutputFileName_ = (cfg.exists("indOutputFileName")) ? cfg.getParameter<std::string>("indOutputFileName") : "";
   if (!indOutputFileName_.empty() && indOutputFileName_.find('.') == std::string::npos) {
     edm::LogError("TauDQMHistPlotter") << " Failed to determine type of graphics format from indOutputFileName = "
                                        << indOutputFileName_ << " !!";
     cfgError_ = 1;
   }
   //std::cout << " indOutputFileName = " << indOutputFileName_ << std::endl;
 
   //--- check that exactly one type of output is specified for the plots
   //    (either separate graphics files displaying one plot each
   //     or postscript file displaying all plots on successive pages;
   //     cannot create both types of output simultaneously,
   //     as TCanvas::Print seems to interfere with TPostScript::NewPage)
   if (outputFileName_.empty() && indOutputFileName_.empty()) {
     edm::LogError("TauDQMHistPlotter") << " Either outputFileName or indOutputFileName must be specified !!";
     cfgError_ = 1;
   }
 
   if (!outputFileName_.empty() && !indOutputFileName_.empty()) {
     edm::LogError("TauDQMHistPlotter") << " Must not specify outputFileName and indOutputFileName simultaneously !!";
     cfgError_ = 1;
   }
 
   if (verbosity)
     std::cout << "done." << std::endl;
 }

TauDQMHistPlotter::~TauDQMHistPlotter ( )

override

Definition at line 881 of file DQMHistPlotter.cc.

                                       {
   // nothing to be done yet...
 }

Member Function Documentation

void TauDQMHistPlotter::analyze	(	const edm::Event &	,
		const edm::EventSetup &
	)

overridevirtual

Implements edm::EDAnalyzer.

Definition at line 885 of file DQMHistPlotter.cc.

                                                                      {
   // nothing to be done yet...
 }

void TauDQMHistPlotter::endRun	(	const edm::Run &	r,
		const edm::EventSetup &	c
	)

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 889 of file DQMHistPlotter.cc.

                                                                       {
   if (verbosity)
     std::cout << "<TauDQMHistPlotter::endJob>:" << std::endl;
 
   //--- check that configuration parameters contain no errors
   if (cfgError_) {
     edm::LogError("endJob") << " Error in Configuration ParameterSet --> histograms will NOT be plotted !!";
     return;
   }
 
   //--- check that DQMStore service is available
   if (!edm::Service<DQMStore>().isAvailable()) {
     edm::LogError("endJob") << " Failed to access dqmStore --> histograms will NOT be plotted !!";
     return;
   }
 
   DQMStore& dqmStore = (*edm::Service<DQMStore>());
 
   //--- stop ROOT from keeping references to all hsitograms
   //TH1::AddDirectory(false);
 
   //--- stop ROOT from opening X-window for canvas output
   //    (in order to be able to run in batch mode)
   gROOT->SetBatch(true);
 
   //--- initialize graphical output;
   //    open postscript file
   TCanvas canvas("TauDQMHistPlotter", "TauDQMHistPlotter", canvasSizeX_, canvasSizeY_);
   canvas.SetFillColor(10);
 
   //--- restrict area in which histograms are drawn to quadratic TPad in the center of the TCanvas,
   //    in order to make space for axis labels...
   //TPad pad("EWKTauPad", "EWKTauPad", 0.02, 0.15, 0.98, 0.85);
   //pad.SetFillColor(10);
   //pad.Draw();
   //pad.Divide(1,1);
   //pad.cd(1);
 
   TPostScript* ps = nullptr;
   if (!outputFileName_.empty()) {
     std::string psFileName =
         (!outputFilePath_.empty()) ? std::string(outputFilePath_).append("/").append(outputFileName_) : outputFileName_;
     ps = new TPostScript(psFileName.data(), 112);
   }
 
   //--- process drawJobs
   for (std::list<cfgEntryDrawJob>::const_iterator drawJob = drawJobs_.begin(); drawJob != drawJobs_.end(); ++drawJob) {
     const std::string& drawJobName = drawJob->name_;
     if (verbosity)
       std::cout << "--> processing drawJob " << drawJobName << "..." << std::endl;
 
     //--- prepare internally used histogram data-structures
     TH1* stackedHistogram_sum = nullptr;
     std::list<TH1*> histogramsToDelete;
     std::list<plotDefEntry*> drawOptionsToDelete;
 
     typedef std::pair<TH1*, const plotDefEntry*> histogram_drawOption_pair;
     std::list<histogram_drawOption_pair> allHistograms;
 
     for (plotDefList::const_iterator plot = drawJob->plots_.begin(); plot != drawJob->plots_.end(); ++plot) {
       std::string dqmMonitorElementName_full =
           dqmDirectoryName(std::string(dqmRootDirectory)).append(plot->dqmMonitorElement_);
       if (verbosity)
         std::cout << " dqmMonitorElementName_full = " << dqmMonitorElementName_full << std::endl;
       MonitorElement* dqmMonitorElement = dqmStore.get(dqmMonitorElementName_full);
 
       TH1* histogram = dqmMonitorElement->getTH1F();
       if (verbosity)
         std::cout << "Got Histogram " << std::endl;
       //      TH1* histogram = ( dqmMonitorElement ) ? dynamic_cast<TH1*>(dqmMonitorElement->getTH1()->Clone()) : NULL;
       //histogramsToDelete.push_back(histogram);
 
       if (histogram == nullptr) {
         edm::LogError("endJob") << " Failed to access dqmMonitorElement = " << dqmMonitorElementName_full << ","
                                 << " needed by drawJob = " << drawJobName << " --> histograms will NOT be plotted !!";
         continue;
       }
 
       if (!histogram->GetSumw2N())
         histogram->Sumw2();
 
       const cfgEntryDrawOption* drawOptionConfig =
           findCfgDef<cfgEntryDrawOption>(plot->drawOptionEntry_, drawOptionEntries_, "drawOptionEntry", drawJobName);
       if (drawOptionConfig == nullptr) {
         edm::LogError("endJob") << " Failed to access information needed by drawJob = " << drawJobName
                                 << " --> histograms will NOT be plotted !!";
         return;
       }
 
       if (drawOptionConfig->drawOption_ == drawOption_eBand) {
         //--- add histogram displaying central value as solid line
         TH1* histogram_centralValue = dynamic_cast<TH1*>(histogram->Clone());
         histogram_centralValue->SetName(std::string(histogram->GetName()).append("_centralValue").data());
         cfgEntryDrawOption drawOptionConfig_centralValue(*drawOptionConfig);
         drawOptionConfig_centralValue.fillColor_ = 0;
         drawOptionConfig_centralValue.fillStyle_ = 0;
         drawOptionConfig_centralValue.drawOption_ = "hist";
         drawOptionConfig_centralValue.drawOptionLegend_ = "l";
         std::string drawOptionName_centralValue = std::string(plot->drawOptionEntry_).append("_centralValue");
         //--- entries in std::map need to be unique,
         //    so need to check whether drawOptionEntry already exists...
         if (drawOptionEntries_.find(drawOptionName_centralValue) == drawOptionEntries_.end())
           drawOptionEntries_.insert(std::pair<std::string, cfgEntryDrawOption>(
               drawOptionName_centralValue,
               cfgEntryDrawOption(drawOptionName_centralValue, drawOptionConfig_centralValue)));
         plotDefEntry* plot_centralValue = new plotDefEntry(*plot);
         plot_centralValue->drawOptionEntry_ = drawOptionName_centralValue;
         allHistograms.push_back(histogram_drawOption_pair(histogram_centralValue, plot_centralValue));
         histogramsToDelete.push_back(histogram_centralValue);
         drawOptionsToDelete.push_back(plot_centralValue);
 
         //--- add histogram displaying uncertainty as shaded error band
         TH1* histogram_ErrorBand = dynamic_cast<TH1*>(histogram->Clone());
         histogram_ErrorBand->SetName(std::string(histogram->GetName()).append("_ErrorBand").data());
         cfgEntryDrawOption drawOptionConfig_ErrorBand(*drawOptionConfig);
         drawOptionConfig_ErrorBand.markerColor_ = drawOptionConfig_ErrorBand.fillColor_;
         drawOptionConfig_ErrorBand.markerSize_ = 0.;
         drawOptionConfig_ErrorBand.lineColor_ = drawOptionConfig_ErrorBand.fillColor_;
         drawOptionConfig_ErrorBand.lineWidth_ = 0;
         drawOptionConfig_ErrorBand.drawOption_ = "e2";
         drawOptionConfig_ErrorBand.drawOptionLegend_ = "f";
         std::string drawOptionName_ErrorBand = std::string(plot->drawOptionEntry_).append("_ErrorBand");
         //--- entries in std::map need to be unique,
         //    so need to check whether drawOptionEntry already exists...
         if (drawOptionEntries_.find(drawOptionName_ErrorBand) == drawOptionEntries_.end())
           drawOptionEntries_.insert(std::pair<std::string, cfgEntryDrawOption>(
               drawOptionName_ErrorBand, cfgEntryDrawOption(drawOptionName_ErrorBand, drawOptionConfig_ErrorBand)));
         plotDefEntry* plot_ErrorBand = new plotDefEntry(*plot);
         plot_ErrorBand->drawOptionEntry_ = drawOptionName_ErrorBand;
         plot_ErrorBand->isErrorBand_ = true;
         allHistograms.push_back(histogram_drawOption_pair(histogram_ErrorBand, plot_ErrorBand));
         histogramsToDelete.push_back(histogram_ErrorBand);
         drawOptionsToDelete.push_back(plot_ErrorBand);
       } else if (plot->doStack_) {
         TH1* stackedHistogram = dynamic_cast<TH1*>(histogram->Clone());
         if (stackedHistogram_sum)
           stackedHistogram->Add(stackedHistogram_sum);
         stackedHistogram_sum = stackedHistogram;
         histogramsToDelete.push_back(stackedHistogram);
         allHistograms.push_back(histogram_drawOption_pair(stackedHistogram, &(*plot)));
       } else {
         allHistograms.push_back(histogram_drawOption_pair(histogram, &(*plot)));
       }
     }
 
     //--- determine normalization of y-axis
     //    (maximum of any of the histograms included in drawJob)
     double yAxisNorm = 0.;
     for (std::list<histogram_drawOption_pair>::const_iterator it = allHistograms.begin(); it != allHistograms.end();
          ++it) {
       yAxisNorm = TMath::Max(yAxisNorm, it->first->GetMaximum());
     }
     //std::cout << " yAxisNorm = " << yAxisNorm << std::endl;
 
     //--- prepare histograms for drawing
     const cfgEntryAxisX* xAxisConfig = findCfgDef<cfgEntryAxisX>(drawJob->xAxis_, xAxes_, "xAxis", drawJobName);
     const cfgEntryAxisY* yAxisConfig = findCfgDef<cfgEntryAxisY>(drawJob->yAxis_, yAxes_, "yAxis", drawJobName);
     const cfgEntryLegend* legendConfig = findCfgDef<cfgEntryLegend>(drawJob->legend_, legends_, "legend", drawJobName);
     if (xAxisConfig == nullptr || yAxisConfig == nullptr || legendConfig == nullptr) {
       edm::LogError("endJob") << " Failed to access information needed by drawJob = " << drawJobName
                               << " --> histograms will NOT be plotted !!";
       return;
     }
 
     //--- WARNING: need to call
     //              TLegend::TLegend(Double_t, Double_t,Double_t, Double_t, const char* = "", Option_t* = "brNDC")
     //             constructor, as TLegend::TLegend default constructor causes the created TLegend object to behave differently !!
     TLegend legend(defaultLegendPosX,
                    defaultLegendPosY,
                    defaultLegendPosX + defaultLegendSizeX,
                    defaultLegendPosY + defaultLegendSizeY);
     legendConfig->applyTo(&legend);
 
     std::list<histoDrawEntry> smProcessHistogramList;
     std::list<histoDrawEntry> bsmProcessHistogramList;
     std::list<histoDrawEntry> smSumHistogramList;
     std::list<histoDrawEntry> smSumUncertaintyHistogramList;
     std::list<histoDrawEntry> dataHistogramList;
 
     for (std::list<histogram_drawOption_pair>::const_iterator it = allHistograms.begin(); it != allHistograms.end();
          ++it) {
       TH1* histogram = it->first;
       const plotDefEntry* drawOption = it->second;
 
       const cfgEntryDrawOption* drawOptionConfig = findCfgDef<cfgEntryDrawOption>(
           drawOption->drawOptionEntry_, drawOptionEntries_, "drawOptionEntry", drawJobName);
       const cfgEntryProcess* processConfig =
           findCfgDef<cfgEntryProcess>(drawOption->process_, processes_, "process", drawJobName);
       if (drawOptionConfig == nullptr || processConfig == nullptr) {
         edm::LogError("endJob") << " Failed to access information needed by drawJob = " << drawJobName
                                 << " --> histograms will NOT be plotted !!";
         return;
       }
 
       if (!drawJob->title_.empty())
         histogram->SetTitle(drawJob->title_.data());
 
       xAxisConfig->applyTo(histogram);
       yAxisConfig->applyTo(histogram, yAxisNorm);
 
       bool yLogScale = (yAxisConfig->yScale_ == yScale_log) ? true : false;
       //std::cout << " yLogScale = " << yLogScale << std::endl;
       //pad.SetLogy(yLogScale);
       canvas.SetLogy(yLogScale);
 
       drawOptionConfig->applyTo(histogram);
       histogram->SetStats(false);
 
       if (drawOption->isErrorBand_) {
         smSumUncertaintyHistogramList.push_back(histoDrawEntry(histogram, drawOptionConfig->drawOption_.data()));
       } else {
         if (processConfig->type_ == type_smMC) {
           smProcessHistogramList.push_back(histoDrawEntry(histogram, drawOptionConfig->drawOption_.data()));
         } else if (processConfig->type_ == type_bsmMC) {
           bsmProcessHistogramList.push_back(histoDrawEntry(histogram, drawOptionConfig->drawOption_.data()));
         } else if (processConfig->type_ == type_smSumMC) {
           smSumHistogramList.push_back(histoDrawEntry(histogram, drawOptionConfig->drawOption_.data()));
         } else if (processConfig->type_ == type_Data) {
           dataHistogramList.push_back(histoDrawEntry(histogram, drawOptionConfig->drawOption_.data()));
         }
       }
 
       std::string legendEntry, legendDrawOption;
       if (drawOption->isErrorBand_) {
         legendEntry = (!drawOption->legendEntryErrorBand_.empty()) ? drawOption->legendEntryErrorBand_
                                                                    : processConfig->legendEntryErrorBand_;
         legendDrawOption = "f";
       } else {
         legendEntry = (!drawOption->legendEntry_.empty()) ? drawOption->legendEntry_ : processConfig->legendEntry_;
         legendDrawOption = drawOptionConfig->drawOptionLegend_;
       }
 
       legend.AddEntry(histogram, legendEntry.data(), legendDrawOption.data());
     }
 
     std::list<TPaveText> labels;
     for (vstring::const_iterator labelName = drawJob->labels_.begin(); labelName != drawJob->labels_.end();
          ++labelName) {
       const cfgEntryLabel* labelConfig = findCfgDef<cfgEntryLabel>(*labelName, labels_, "label", drawJobName);
 
       TPaveText label;
       labelConfig->applyTo(&label);
 
       labels.push_back(label);
     }
 
     //--- draw histograms
     //   - in the order:
     //    1. uncertainty on sum of all Standard Model processes
     //    2. sum of all Standard Model processes
     //    3. individual Standard Model processes
     //    4. individual beyond the Standard Model processes
     //    5. data
     bool isFirstHistogram = true;
     drawHistograms(smSumUncertaintyHistogramList, isFirstHistogram);
     drawHistograms(smSumHistogramList, isFirstHistogram);
 
     //--- process histograms for individual Standard Model processes
     //    in reverse order, so that most stacked histogram gets drawn first
     for (std::list<histoDrawEntry>::reverse_iterator it = smProcessHistogramList.rbegin();
          it != smProcessHistogramList.rend();
          ++it) {
       std::string drawOption = (isFirstHistogram) ? it->second : std::string(it->second).append("same");
       it->first->Draw(drawOption.data());
       isFirstHistogram = false;
     }
 
     drawHistograms(bsmProcessHistogramList, isFirstHistogram);
     drawHistograms(dataHistogramList, isFirstHistogram);
 
     legend.Draw();
 
     for (std::list<TPaveText>::iterator label = labels.begin(); label != labels.end(); ++label) {
       label->Draw();
     }
 
     //pad.RedrawAxis();
 
     canvas.Update();
     //pad.Update();
 
     if (!indOutputFileName_.empty() && toFile_) {
       int errorFlag = 0;
       std::string modIndOutputFileName = replace_string(indOutputFileName_, plotKeyword, drawJobName, 1, 1, errorFlag);
       if (!errorFlag) {
         std::string fullFileName = (!outputFilePath_.empty())
                                        ? std::string(outputFilePath_).append("/").append(modIndOutputFileName)
                                        : modIndOutputFileName;
         canvas.Print(fullFileName.data());
       } else {
         edm::LogError("endJob") << " Failed to decode indOutputFileName = " << indOutputFileName_ << " --> skipping !!";
       }
     }
 
     if (ps)
       ps->NewPage();
 
     //--- delete temporarily created histogram and drawOption objects
     for (std::list<TH1*>::const_iterator histogram = histogramsToDelete.begin(); histogram != histogramsToDelete.end();
          ++histogram) {
       delete (*histogram);
     }
 
     for (std::list<plotDefEntry*>::const_iterator drawOption = drawOptionsToDelete.begin();
          drawOption != drawOptionsToDelete.end();
          ++drawOption) {
       delete (*drawOption);
     }
   }
 
   //--- close postscript file
   canvas.Clear();
   if (verbosity)
     std::cout << "done." << std::endl;
   if (ps)
     ps->Close();
   delete ps;
 }