hltDiff.cc File Reference

#include <vector>
#include <set>
#include <string>
#include <iostream>
#include <sstream>
#include <fstream>
#include <stdio.h>
#include <iomanip>
#include <memory>
#include <algorithm>
#include <cstring>
#include <unistd.h>
#include <getopt.h>
#include <cstdio>
#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"

Go to the source code of this file.

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 {   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
Ready
Pass
Fail
Exception
Prescaled
Invalid

Definition at line 287 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 1209 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 1215 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 135 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 411 of file hltDiff.cc.

References MessageLogger_cfi::cerr, mps_alisetup::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::unique_ptr<HLTConfigDataEx>(new HLTConfigDataEx(HLTConfigData(pset)));
}

std::string getProcessNameFromBranch

(

std::string const &

branch

)

Definition at line 405 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 1595 of file hltDiff.cc.

References EnergyCorrector::c, MessageLogger_cfi::cerr, HltDiff::compare(), HltDiff::csv_out, HltDiff::debug, error(), cmsRelvalreport::exit, HltDiff::file_check, HltDiff::ignore_prescales, HltDiff::json_out, hpstanc_transforms::max, HltDiff::max_events, HltDiff::new_files, HltDiff::new_process, NULL, HltDiff::old_files, HltDiff::old_process, TSGForRoadSearch_cfi::option, HltDiff::output_file, HltDiff::quiet, HltDiff::root_out, HltDiff::usage(), and HltDiff::verbose.

                                 {
  // 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
  HltDiff* 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 && NULL != 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 465 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 296 of file hltDiff.cc.

References Invalid, and python.rootplot.argparse::message.

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 306 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 334 of file hltDiff.cc.

References Fail, diffTwoXMLs::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 345 of file hltDiff.cc.

References trigger::TriggerObject::eta(), trigger::TriggerEvent::filterIds(), trigger::TriggerEvent::filterIndex(), trigger::TriggerEvent::filterKeys(), trigger::TriggerEvent::getObjects(), i, trigger::TriggerObject::id(), diffTreeTool::index, 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 375 of file hltDiff.cc.

References begin, trigger::TriggerEvent::collectionKey(), trigger::TriggerEvent::collectionTags(), end, trigger::TriggerObject::eta(), spr::find(), trigger::TriggerEvent::getObjects(), trigger::TriggerObject::id(), diffTreeTool::index, 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 319 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;
  }
}