hltDiff.cc File Reference

#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 <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 {   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 241 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 1224 of file hltDiff.cc.

References validate-o2o-wbm::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 1229 of file hltDiff.cc.

References EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::cerr, check_file(), and mergeVDriftHistosByStation::file.

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

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

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

Definition at line 45 of file hltDiff.cc.

References relativeConstraints::error.

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

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

Definition at line 50 of file hltDiff.cc.

References relativeConstraints::error.

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

const char* event_state

(

bool

state

)

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

References EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::cerr, submitPVResolutionJobs::config, beamvalidation::exit(), edm::pset::Registry::getMapped(), getProcessNameFromBranch(), isotrackTrainRegressor::history, edm::pset::Registry::instance(), edm::ProcessConfiguration::parameterSetID(), and TrackValidation_cff::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 356 of file hltDiff.cc.

References submitPVValidationJobs::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 1628 of file hltDiff.cc.

References c, EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::cerr, relativeConstraints::error, beamvalidation::exit(), ValidationMatrix::hlt, and SiStripPI::max.

                                {
  // 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 414 of file hltDiff.cc.

References TriggerDiff::count, TriggerDiff::format(), TriggerDiff::gained, TriggerDiff::internal, TriggerDiff::lost, and submitPVResolutionJobs::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 250 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 259 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 286 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 297 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(), submitPVResolutionJobs::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 327 of file hltDiff.cc.

References SplitLinear::begin, trigger::TriggerEvent::collectionKey(), trigger::TriggerEvent::collectionTags(), dataset::end, trigger::TriggerObject::eta(), spr::find(), trigger::TriggerEvent::getObjects(), trigger::TriggerObject::id(), submitPVResolutionJobs::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 272 of file hltDiff.cc.

References submitPVResolutionJobs::count, dataset::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;
  }
}