#include <vector>
#include <set>
#include <string>
#include <iostream>
#include <sstream>
#include <fstream>
#include <cstdio>
#include <iomanip>
#include <memory>
#include <algorithm>
#include <cstring>
#include <unistd.h>
#include <getopt.h>
#include <cmath>
#include <boost/algorithm/string.hpp>
#include <boost/filesystem.hpp>
#include <TFile.h>
#include <TCanvas.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TGraphAsymmErrors.h>
#include "FWCore/Common/interface/TriggerNames.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/ParameterSet/interface/Registry.h"
#include "DataFormats/Common/interface/TriggerResults.h"
#include "DataFormats/HLTReco/interface/TriggerObject.h"
#include "DataFormats/HLTReco/interface/TriggerEvent.h"
#include "DataFormats/FWLite/interface/Handle.h"
#include "DataFormats/FWLite/interface/Event.h"
#include "DataFormats/FWLite/interface/ChainEvent.h"
#include "HLTrigger/HLTcore/interface/HLTConfigData.h"

Classes
struct	SummaryOutputProducer::Event

struct	SummaryOutputProducer::GenericSummary

class	HLTCommonConfig

class	HLTConfigDataEx

class	HLTConfigInterface

class	HltDiff

struct	JsonOutputProducer::JsonConfiguration

struct	JsonOutputProducer::JsonConfigurationBlock

struct	JsonOutputProducer::JsonEvent

struct	JsonOutputProducer::JsonEventState

class	JsonOutputProducer

struct	JsonOutputProducer::JsonTriggerEventState

struct	JsonOutputProducer::JsonVars

struct	SummaryOutputProducer::Pair

class	SummaryOutputProducer

struct	TriggerDiff

struct	SummaryOutputProducer::TriggerSummary

class	HLTCommonConfig::View

Enumerations
enum	State { InvalidLinkId, InvalidROCId, InvalidPixelId, Unknown, Ready = edm::hlt::Ready, Pass = edm::hlt::Pass, Fail = edm::hlt::Fail, Exception = edm::hlt::Exception, Prescaled, Invalid }

Functions
bool	check_file (std::string const &file)

bool	check_files (std::vector< std::string > const &files)

void	error (std::ostream &out)

void	error (std::ostream &out, const char *message)

void	error (std::ostream &out, const std::string &message)

const char *	event_state (bool state)

std::unique_ptr< HLTConfigDataEx >	getHLTConfigData (fwlite::EventBase const &event, std::string process)

std::string	getProcessNameFromBranch (std::string const &branch)

int	main (int argc, char **argv)

std::ostream &	operator<< (std::ostream &out, TriggerDiff diff)

const char *	path_state (State state)

State	prescaled_state (int state, int path, int module, HLTConfigInterface const &config)

void	print_detailed_path_state (std::ostream &out, State state, int path, int module, HLTConfigInterface const &config)

void	print_trigger_candidates (std::ostream &out, trigger::TriggerEvent const &summary, edm::InputTag const &filter)

void	print_trigger_collection (std::ostream &out, trigger::TriggerEvent const &summary, std::string const &tag)

std::string	strip_process_name (std::string const &s)

Enumeration Type Documentation

enum State

Enumerator
InvalidLinkId
InvalidROCId
InvalidPixelId
Unknown
Ready
Pass
Fail
Exception
Prescaled
Invalid

Definition at line 288 of file hltDiff.cc.

            {
   Ready     = edm::hlt::Ready,
   Pass      = edm::hlt::Pass,
   Fail      = edm::hlt::Fail,
   Exception = edm::hlt::Exception,
   Prescaled,
   Invalid
 };

Function Documentation

bool check_file ( std::string const & file )

Definition at line 1210 of file hltDiff.cc.

References f.

Referenced by check_files().

                                         {
   std::unique_ptr<TFile> f(TFile::Open(file.c_str()));
   return (f and not f->IsZombie());
 }

bool check_files ( std::vector< std::string > const & files )

Definition at line 1216 of file hltDiff.cc.

References MessageLogger_cfi::cerr, check_file(), FrontierConditions_GlobalTag_cff::file, and RemoveAddSevLevel::flag.

Referenced by HltDiff::compare().

                                                      {
   bool flag = true;
   for (auto const & file: files)
     if (not check_file(file)) {
       flag = false;
       std::cerr << "hltDiff: error: file " << file << " does not exist, or is not a regular file." << std::endl;
     }
   return flag;
 }

void error ( std::ostream & out )

Definition at line 45 of file hltDiff.cc.

Referenced by error(), and main().

                              {
     out << "Try 'hltDiff --help' for more information" << std::endl;
 }

void error	(	std::ostream &	out,
		const char *	message
	)

Definition at line 49 of file hltDiff.cc.

References error().

                                                    {
   out << message << std::endl;
   error(out);
 }

void error	(	std::ostream &	out,
		const std::string &	message
	)

Definition at line 54 of file hltDiff.cc.

References error().

                                                         {
   out << message << std::endl;
   error(out);
 }

const char* event_state ( bool state )

Definition at line 136 of file hltDiff.cc.

Referenced by HltDiff::compare().

                                      {
   return state ? "accepted" : "rejected";
 }

std::unique_ptr<HLTConfigDataEx> getHLTConfigData	(	fwlite::EventBase const &	event,
		std::string	process
	)

Definition at line 412 of file hltDiff.cc.

References MicroEventContent_cff::branch, MessageLogger_cfi::cerr, looper::config, cmsRelvalreport::exit, edm::pset::Registry::getMapped(), getProcessNameFromBranch(), edm::pset::Registry::instance(), edm::ProcessConfiguration::parameterSetID(), and muonDTDigis_cfi::pset.

Referenced by HltDiff::compare().

                                                                                                   {
   auto const & history = event.processHistory();
   if (process.empty()) {
     // determine the process name from the most recent "TriggerResults" object
     auto const & branch  = event.getBranchNameFor( edm::Wrapper<edm::TriggerResults>::typeInfo(), "TriggerResults", "", process.c_str() );
     process = getProcessNameFromBranch( branch );
   }
 
   edm::ProcessConfiguration config;
   if (not history.getConfigurationForProcess(process, config)) {
     std::cerr << "error: the process " << process << " is not in the Process History" << std::endl;
     exit(1);
   }
   const edm::ParameterSet* pset = edm::pset::Registry::instance()->getMapped(config.parameterSetID());
   if (pset == nullptr) {
     std::cerr << "error: the configuration for the process " << process << " is not available in the Provenance" << std::endl;
     exit(1);
   }
   return std::make_unique<HLTConfigDataEx>(HLTConfigData(pset));
 }

std::string getProcessNameFromBranch ( std::string const & branch )

Definition at line 406 of file hltDiff.cc.

References split.

Referenced by getHLTConfigData().

                                                              {
   std::vector<boost::iterator_range<std::string::const_iterator>> tokens;
   boost::split(tokens, branch, boost::is_any_of("_."), boost::token_compress_off);
   return boost::copy_range<std::string>(tokens[3]);
 }

int main	(	int	argc,
		char **	argv
	)

Definition at line 1596 of file hltDiff.cc.

References EnergyCorrector::c, MessageLogger_cfi::cerr, error(), cmsRelvalreport::exit, ValidationMatrix::hlt, SiStripPI::max, and TSGForRoadSearch_cfi::option.

                                  {
   // options
   const char optstring[] = "dfo:O:n:N:m:pcjrF:v::hq";
   const option longopts[] = {
     option{ "debug",        no_argument,        nullptr, 'd' },
     option{ "file-check",   no_argument,        nullptr, 'f' },
     option{ "old-files",    required_argument,  nullptr, 'o' },
     option{ "old-process",  required_argument,  nullptr, 'O' },
     option{ "new-files",    required_argument,  nullptr, 'n' },
     option{ "new-process",  required_argument,  nullptr, 'N' },
     option{ "max-events",   required_argument,  nullptr, 'm' },
     option{ "prescales",    no_argument,        nullptr, 'p' },
     option{ "csv-output",   optional_argument,  nullptr, 'c' },
     option{ "json-output",  optional_argument,  nullptr, 'j' },
     option{ "root-output",  optional_argument,  nullptr, 'r' },
     option{ "output-file",  optional_argument,  nullptr, 'F' },
     option{ "verbose",      optional_argument,  nullptr, 'v' },
     option{ "help",         no_argument,        nullptr, 'h' },
     option{ "quiet",        no_argument,        nullptr, 'q' },
   };
 
   // Creating an HltDiff object with the default configuration
   auto  hlt = new HltDiff();
 
   // parse the command line options
   int c = -1;
   while ((c = getopt_long(argc, argv, optstring, longopts, nullptr)) != -1) {
     switch (c) {
       case 'd':
         hlt->debug = true;
         break;
 
       case 'f':
         hlt->file_check = true;
         break;
 
       case 'o':
         hlt->old_files.emplace_back(optarg);
         while (optind < argc) {
           if (argv[optind][0] == '-')
             break;
           hlt->old_files.emplace_back(argv[optind]);
           ++optind;
         }
         break;
 
       case 'O':
         hlt->old_process = optarg;
         break;
 
       case 'n':
         hlt->new_files.emplace_back(optarg);
         while (optind < argc) {
           if (argv[optind][0] == '-')
             break;
           hlt->new_files.emplace_back(argv[optind]);
           ++optind;
         }
         break;
 
       case 'N':
         hlt->new_process = optarg;
         break;
 
       case 'm':
         hlt->max_events = atoi(optarg);
         break;
 
       case 'p':
         hlt->ignore_prescales = false;
         break;
 
       case 'c':
         hlt->csv_out = true;
         break;
 
       case 'j':
         hlt->json_out = true;
         break;
 
       case 'r':
         hlt->root_out = true;
         break;
 
       case 'F':
         hlt->output_file = optarg;
         break;
 
       case 'v':
         hlt->verbose = 1;
         if (optarg) {
           hlt->verbose = std::max(1, atoi(optarg));
         } else if (!optarg && nullptr != argv[optind] && '-' != argv[optind][0]) {
           // workaround for a bug in getopt which doesn't allow space before optional arguments
           const char *tmp_optarg = argv[optind++];
           hlt->verbose = std::max(1, atoi(tmp_optarg));
         }
         break;
 
       case 'h':
         hlt->usage(std::cerr);
         exit(0);
         break;
 
       case 'q':
         hlt->quiet = true;
         break;
 
       default:
         error(std::cerr);
         exit(1);
         break;
     }
   }
 
   if (hlt->old_files.empty()) {
     error(std::cerr, "hltDiff: please specify the 'old' file(s)");
     exit(1);
   }
   if (hlt->new_files.empty()) {
     error(std::cerr, "hltDiff: please specify the 'new' file(s)");
     exit(1);
   }
 
   hlt->compare();
 
   return 0;
 }

std::ostream& operator<<	(	std::ostream &	out,
		TriggerDiff	diff
	)

Definition at line 466 of file hltDiff.cc.

References TriggerDiff::count, TriggerDiff::format(), TriggerDiff::gained, TriggerDiff::internal, TriggerDiff::lost, and MillePedeFileConverter_cfg::out.

                                                             {
   out << std::setw(12) << diff.count
       << std::setw(12) << TriggerDiff::format(diff.gained, '+')
       << std::setw(12) << TriggerDiff::format(diff.lost, '-')
       << std::setw(12) << TriggerDiff::format(diff.internal, '~');
   return out;
 }

const char* path_state ( State state )

Definition at line 297 of file hltDiff.cc.

References Invalid.

Referenced by HltDiff::compare(), and print_detailed_path_state().

                                      {
   static const char * message[] = { "not run", "accepted", "rejected", "exception", "prescaled", "invalid" };
 
   if (state > 0 and state < Invalid)
     return message[state];
   else
     return message[Invalid];
 }

State prescaled_state	(	int	state,
		int	path,
		int	module,
		HLTConfigInterface const &	config
	)

inline

Definition at line 307 of file hltDiff.cc.

References Fail, Prescaled, and HLTConfigInterface::prescaler().

Referenced by HltDiff::compare().

                                                                                           {
   if (state == Fail and config.prescaler(path, module))
     return Prescaled;
   return (State) state;
 }

void print_detailed_path_state	(	std::ostream &	out,
		State	state,
		int	path,
		int	module,
		HLTConfigInterface const &	config
	)

Definition at line 335 of file hltDiff.cc.

References Fail, label, HLTConfigInterface::moduleLabel(), HLTConfigInterface::moduleType(), and path_state().

Referenced by HltDiff::compare().

                                                                                                                        {
   auto const & label = config.moduleLabel(path, module);
   auto const & type  = config.moduleType(path, module);
 
   out << "'" << path_state(state) << "'";
   if (state == Fail)
     out << " by module " << module << " '" << label << "' [" << type << "]";
   else if (state == Exception)
     out << " at module " << module << " '" << label << "' [" << type << "]";
 }

void print_trigger_candidates	(	std::ostream &	out,
		trigger::TriggerEvent const &	summary,
		edm::InputTag const &	filter
	)

Definition at line 346 of file hltDiff.cc.

References trigger::TriggerObject::eta(), trigger::TriggerEvent::filterIds(), trigger::TriggerEvent::filterIndex(), trigger::TriggerEvent::filterKeys(), trigger::TriggerEvent::getObjects(), mps_fire::i, trigger::TriggerObject::id(), crabWrapper::key, trigger::TriggerObject::mass(), trigger::TriggerObject::phi(), trigger::TriggerObject::pt(), and trigger::TriggerEvent::sizeFilters().

Referenced by HltDiff::compare().

                                                                                                                  {
   // find the index of the collection of trigger candidates corresponding to the filter
   unsigned int index = summary.filterIndex(filter);
 
   if (index >= summary.sizeFilters()) {
     // the collection of trigger candidates corresponding to the filter could not be found
     out << "            not found\n";
     return;
   }
 
   if (summary.filterKeys(index).empty()) {
     // the collection of trigger candidates corresponding to the filter is empty
     out << "            none\n";
     return;
   }
 
   for (unsigned int i = 0; i < summary.filterKeys(index).size(); ++i) {
     auto key = summary.filterKeys(index)[i];
     auto id  = summary.filterIds(index)[i];
     trigger::TriggerObject const & candidate = summary.getObjects().at(key);
     out << "            "
         << "filter id: " << id               << ", "
         << "object id: " << candidate.id()   << ", "
         << "pT: "        << candidate.pt()   << ", "
         << "eta: "       << candidate.eta()  << ", "
         << "phi: "       << candidate.phi()  << ", "
         << "mass: "      << candidate.mass() << "\n";
   }
 }

void print_trigger_collection	(	std::ostream &	out,
		trigger::TriggerEvent const &	summary,
		std::string const &	tag
	)

Definition at line 376 of file hltDiff.cc.

References begin, trigger::TriggerEvent::collectionKey(), trigger::TriggerEvent::collectionTags(), end, trigger::TriggerObject::eta(), spr::find(), trigger::TriggerEvent::getObjects(), trigger::TriggerObject::id(), crabWrapper::key, trigger::TriggerObject::mass(), trigger::TriggerObject::phi(), trigger::TriggerObject::pt(), and GlobalPosition_Frontier_DevDB_cff::tag.

Referenced by HltDiff::compare().

                                                                                                             {
   auto iterator = std::find(summary.collectionTags().begin(), summary.collectionTags().end(), tag);
   if (iterator == summary.collectionTags().end()) {
     // the collection of trigger candidates could not be found
     out << "            not found\n";
     return;
   }
 
   unsigned int index = iterator - summary.collectionTags().begin();
   unsigned int begin = (index == 0) ? 0 : summary.collectionKey(index - 1);
   unsigned int end   = summary.collectionKey(index);
 
   if (end == begin) {
     // the collection of trigger candidates is empty
     out << "            none\n";
     return;
   }
 
   for (unsigned int key = begin; key < end; ++key) {
     trigger::TriggerObject const & candidate = summary.getObjects().at(key);
     out << "            "
         << "object id: " << candidate.id()   << ", "
         << "pT: "        << candidate.pt()   << ", "
         << "eta: "       << candidate.eta()  << ", "
         << "phi: "       << candidate.phi()  << ", "
         << "mass: "      << candidate.mass() << "\n";
   }
 }

std::string strip_process_name ( std::string const & s )

Definition at line 320 of file hltDiff.cc.

References KineDebug3::count(), end, and alignCSCRings::s.

Referenced by HltDiff::compare().

                                                   {
   if (std::count(s.begin(), s.end(), ':') == 2) {
     // remove the process name and the second ':' separator
     size_t end = s.find_last_of(':');
     if (end > 0 and s.at(end-1) == ':')
       // no instance name, remove also the first ':' separator
       --end;
     return s.substr(0, end);
   } else {
     // no process name, return the string unchanged
     return s;
   }
 }

Classes

Enumerations

Functions

Enumeration Type Documentation

Function Documentation