#include <vector>
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <memory>
#include <cstring>
#include <unistd.h>
#include <getopt.h>
#include <boost/algorithm/string.hpp>
#include <boost/filesystem.hpp>
#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
class	HLTCommonConfig

class	HLTConfigDataEx

class	HLTConfigInterface

struct	TriggerDiff

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	compare (std::vector< std::string > const &old_files, std::string const &old_process, std::vector< std::string > const &new_files, std::string const &new_process, unsigned int max_events, bool ignore_prescales, int verbose)

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)

void	usage (std::ostream &out)

Enumeration Type Documentation

enum State

Enumerator
Ready
Pass
Fail
Exception
Prescaled
Invalid

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

References AlCaHLTBitMon_ParallelJobs::p, and fed_dqm_sourceclient-live_cfg::path.

Referenced by check_files().

                                         {
   boost::filesystem::path p(file);
 
   // check if the file exists
   if (not boost::filesystem::exists(p))
     return false;
 
   // resolve the file name to canonical form
   p = boost::filesystem::canonical(p);
   if (not boost::filesystem::exists(p))
     return false;
 
   // check for a regular file
   if (not boost::filesystem::is_regular_file(p))
     return false;
 
   return true;
 }

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

Definition at line 495 of file hltDiff.cc.

References ecal_dqm_sourceclient-live_cfg::cerr, check_file(), and mergeVDriftHistosByStation::file.

Referenced by 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 compare	(	std::vector< std::string > const &	old_files,
		std::string const &	old_process,
		std::vector< std::string > const &	new_files,
		std::string const &	new_process,
		unsigned int	max_events,
		bool	ignore_prescales,
		int	verbose
	)

Definition at line 506 of file hltDiff.cc.

References ecal_dqm_sourceclient-live_cfg::cerr, check_files(), runEdmFileComparison::collection, counter, gather_cfg::cout, event_state(), HLTCommonConfig::First, fwlite::Handle< T >::getByLabel(), getHLTConfigData(), HLTCommonConfig::HLTCommonConfig(), i, min(), HLTConfigInterface::moduleLabel(), cscdqm::h::names, or, AlCaHLTBitMon_ParallelJobs::p, Pass, Prescaled, prescaled_state(), print_detailed_path_state(), print_trigger_candidates(), print_trigger_collection(), HLTConfigInterface::processName(), HLTCommonConfig::Second, HLTConfigInterface::size(), HLTConfigInterface::triggerIndex(), and HLTConfigInterface::triggerName().

Referenced by TTUTrackingAlg::alignTracks(), TrackingMonitor::bookHistograms(), l1t::ConditionEvaluation::checkRangeDeltaEta(), muonisolation::CaloExtractorByAssociator::deposits(), GeneralHLTOffline::dqmBeginRun(), PrintGeomMatInfo::dumpG4LVLeafWithMat(), main(), TrackingMonitor::setMaxMinBin(), and TrackingMonitor::setNclus().

                                                                           {
 
   std::shared_ptr<fwlite::ChainEvent> old_events;
   std::shared_ptr<fwlite::ChainEvent> new_events;
 
   if (check_files(old_files))
     old_events = std::make_shared<fwlite::ChainEvent>(old_files);
   else
     return;
 
   if (new_files.size() == 1 and new_files[0] == "-")
     new_events = old_events;
   else if (check_files(new_files))
     new_events = std::make_shared<fwlite::ChainEvent>(new_files);
   else
     return;
 
   std::unique_ptr<HLTConfigDataEx> old_config_data;
   std::unique_ptr<HLTConfigDataEx> new_config_data;
   std::unique_ptr<HLTCommonConfig> common_config;
   HLTConfigInterface const * old_config = nullptr;
   HLTConfigInterface const * new_config = nullptr;
 
   unsigned int counter = 0;
   unsigned int affected = 0;
   bool new_run = true;
   std::vector<TriggerDiff> differences;
 
   // loop over the reference events
   for (old_events->toBegin(); not old_events->atEnd(); ++(*old_events)) {
 
     // seek the same event in the "new" files
     edm::EventID const& id = old_events->id();
     if (new_events != old_events and not new_events->to(id)) {
       std::cerr << "run " << id.run() << ", lumi " << id.luminosityBlock() << ", event " << id.event() << ": not found in the 'new' files, skipping." << std::endl;
       continue;
     }
 
     // read the TriggerResults and TriggerEvent
     fwlite::Handle<edm::TriggerResults> old_results_h;
     old_results_h.getByLabel<fwlite::Event>(* old_events->event(), "TriggerResults", "", old_process.c_str());
     auto const & old_results = * old_results_h;
 
     fwlite::Handle<trigger::TriggerEvent> old_summary_h;
     old_summary_h.getByLabel<fwlite::Event>(* old_events->event(), "hltTriggerSummaryAOD", "", old_process.c_str());
     auto const & old_summary = * old_summary_h;
 
     fwlite::Handle<edm::TriggerResults> new_handle;
     new_handle.getByLabel<fwlite::Event>(* new_events->event(), "TriggerResults", "", new_process.c_str());
     auto const & new_results = * new_handle;
 
     fwlite::Handle<trigger::TriggerEvent> new_summary_h;
     new_summary_h.getByLabel<fwlite::Event>(* new_events->event(), "hltTriggerSummaryAOD", "", new_process.c_str());
     auto const & new_summary = * new_summary_h;
 
     // initialise the trigger configuration
     if (new_run) {
       new_run = false;
       old_events->fillParameterSetRegistry();
       new_events->fillParameterSetRegistry();
 
       old_config_data = getHLTConfigData(* old_events->event(), old_process);
       new_config_data = getHLTConfigData(* new_events->event(), new_process);
       if (new_config_data->triggerNames() == old_config_data->triggerNames()) {
         old_config = old_config_data.get();
         new_config = new_config_data.get();
       } else {
         common_config = std::unique_ptr<HLTCommonConfig>(new HLTCommonConfig(*old_config_data, *new_config_data));
         old_config = & common_config->getView(HLTCommonConfig::Index::First);
         new_config = & common_config->getView(HLTCommonConfig::Index::Second);
         std::cerr << "Warning: old and new TriggerResults come from different HLT menus. Only the common triggers will be compared:" << std::endl;
         for (unsigned int i = 0; i < old_config->size(); ++i)
           std::cerr << "    " << old_config->triggerName(i) << std::endl;
         std::cerr << std::endl;
       }
 
       differences.clear();
       differences.resize(old_config->size());
     }
 
     // compare the TriggerResults
     bool needs_header = true;
     bool affected_event = false;
     for (unsigned int p = 0; p < old_config->size(); ++p) {
       // FIXME explicitly converting the indices is a hack, it should be properly encapsulated instead
       unsigned int old_index = old_config->triggerIndex(p);
       unsigned int new_index = new_config->triggerIndex(p);
       State old_state = prescaled_state(old_results.state(old_index), p, old_results.index(old_index), * old_config);
       State new_state = prescaled_state(new_results.state(new_index), p, new_results.index(new_index), * new_config);
 
       if (old_state == Pass)
         ++differences[p].count;
 
       bool flag = false;
       if (not ignore_prescales or (old_state != Prescaled and new_state != Prescaled)) {
         if (old_state == Pass and new_state != Pass) {
           ++differences[p].lost;
           flag = true;
         } else if (old_state != Pass and new_state == Pass) {
           ++differences[p].gained;
           flag = true;
         } else if (old_results.index(old_index) != new_results.index(new_index)) {
           ++differences[p].internal;
           flag = true;
         }
       }
 
       if (flag) {
         affected_event = true;
 
         if (verbose > 0) {
           if (needs_header) {
             needs_header = false;
             std::cout << "run " << id.run() << ", lumi " << id.luminosityBlock() << ", event " << id.event() << ": "
                       << "old result is '" << event_state(old_results.accept()) << "', "
                       << "new result is '" << event_state(new_results.accept()) << "'"
                       << std::endl;
           }
           // print the Trigger path and filter responsible for the discrepancy
           std::cout << "    Path " << old_config->triggerName(p) << ":\n"
                     << "        old state is ";
           print_detailed_path_state(std::cout, old_state, p, old_results.index(old_index), * old_config);
           std::cout << ",\n"
                     << "        new state is ";
           print_detailed_path_state(std::cout, new_state, p, new_results.index(new_index), * new_config);
           std::cout << std::endl;
         }
         if (verbose > 1) {
           // print TriggerObjects for the filter responsible for the discrepancy
           unsigned int module = std::min(old_results.index(old_index), new_results.index(new_index));
           std::cout << "    Filter " << old_config->moduleLabel(p, module) << ":\n";
           std::cout << "        old trigger candidates:\n";
           print_trigger_candidates(std::cout, old_summary, edm::InputTag(old_config->moduleLabel(p, module), "", old_config->processName()));
           std::cout << "        new trigger candidates:\n";
           print_trigger_candidates(std::cout, new_summary, edm::InputTag(new_config->moduleLabel(p, module), "", new_config->processName()));
         }
         if (verbose > 0)
           std::cout << std::endl;
       }
     }
     if (affected_event)
       ++affected;
 
     // compare the TriggerEvent
     if (affected_event and verbose > 2) {
       std::set<std::string> names;
       names.insert(old_summary.collectionTags().begin(), old_summary.collectionTags().end());
       names.insert(new_summary.collectionTags().begin(), new_summary.collectionTags().end());
       for (auto const & collection: names) {
         std::cout << "    Collection " << collection << ":\n";
         std::cout << "        old trigger candidates:\n";
         print_trigger_collection(std::cout, old_summary, collection);
         std::cout << "        new trigger candidates:\n";
         print_trigger_collection(std::cout, new_summary, collection);
         std::cout << std::endl;
       }
     }
 
     ++counter;
     if (max_events and counter >= max_events)
       break;
   }
 
   if (not counter) {
     std::cout << "There are no common events between the old and new files." << std::endl;
   } else {
     std::cout << "Found " << affected << " events out of " << counter << " with differences:\n" << std::endl;
     std::cout << std::setw(12) << "Events" << std::setw(12) << "Accepted" << std::setw(12) << "Gained" << std::setw(12) << "Lost" << std::setw(12) << "Other" << "  " << "Trigger" << std::endl;
     for (unsigned int p = 0; p < old_config->size(); ++p)
       std::cout << std::setw(12) << counter << differences[p] << "  " << old_config->triggerName(p) << std::endl;
   }
 }

void error ( std::ostream & out )

Definition at line 72 of file hltDiff.cc.

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

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

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

References relativeConstraints::error.

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

const char* event_state ( bool state )

Definition at line 162 of file hltDiff.cc.

Referenced by compare().

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

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

Definition at line 416 of file hltDiff.cc.

References ecal_dqm_sourceclient-live_cfg::cerr, HDQMDatabaseProducer::config, cmsRelvalreport::exit, edm::pset::Registry::getMapped(), getProcessNameFromBranch(), edm::pset::Registry::instance(), and edm::ProcessConfiguration::parameterSetID().

Referenced by 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 410 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 682 of file hltDiff.cc.

References EnergyCorrector::c, ecal_dqm_sourceclient-live_cfg::cerr, compare(), relativeConstraints::error, cmsRelvalreport::exit, AlCaHLTBitMon_QueryRunRegistry::string, geometryDiff::usage, and verbose.

                                  {
   // options
   const char optstring[] = "o:O:n:N:m:pvh";
   const option longopts[] = {
     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{ "verbose",      no_argument,        nullptr, 'v' },
     option{ "help",         no_argument,        nullptr, 'h' },
   };
 
   // default values
   std::vector<std::string>  old_files;
   std::string               old_process("");
   std::vector<std::string>  new_files;
   std::string               new_process("");
   unsigned int              max_events = 0;
   bool                      ignore_prescales = true;
   unsigned int              verbose = 0;
 
   // parse the command line options
   int c = -1;
   while ((c = getopt_long(argc, argv, optstring, longopts, nullptr)) != -1) {
     switch (c) {
       case 'o':
         old_files.emplace_back(optarg);
         while (optind < argc) {
           if (argv[optind][0] == '-')
             break;
           old_files.emplace_back(argv[optind]);
           ++optind;
         }
         break;
 
       case 'O':
         old_process = optarg;
         break;
 
       case 'n':
         new_files.emplace_back(optarg);
         while (optind < argc) {
           if (argv[optind][0] == '-')
             break;
           new_files.emplace_back(argv[optind]);
           ++optind;
         }
         break;
 
       case 'N':
         new_process = optarg;
         break;
 
       case 'm':
         max_events = atoi(optarg);
         break;
 
       case 'p':
         ignore_prescales = false;
         break;
 
       case 'v':
         ++verbose;
         break;
 
       case 'h':
         usage(std::cerr);
         exit(0);
         break;
 
       default:
         error(std::cerr);
         exit(1);
         break;
     }
   }
 
   if (old_files.empty()) {
     error(std::cerr, "hltDiff: please specify the 'old' file(s)");
     exit(1);
   }
   if (new_files.empty()) {
     error(std::cerr, "hltDiff: please specify the 'new' file(s)");
     exit(1);
   }
 
   compare(old_files, old_process, new_files, new_process, max_events, ignore_prescales, verbose);
 
   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 dbtoconf::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 323 of file hltDiff.cc.

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

Referenced by 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 333 of file hltDiff.cc.

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

Referenced by 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 339 of file hltDiff.cc.

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

Referenced by 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 350 of file hltDiff.cc.

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

Referenced by 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 380 of file hltDiff.cc.

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

Referenced by 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";
   }
 }

void usage ( std::ostream & out )

Definition at line 33 of file hltDiff.cc.

                              {
   out << "\
 usage: hltDiff -o|--old-files FILE1.ROOT [FILE2.ROOT ...] [-O|--old-process LABEL[:INSTANCE[:PROCESS]]]\n\
                -n|--new-files FILE1.ROOT [FILE2.ROOT ...] [-N|--new-process LABEL[:INSTANCE[:PROCESS]]]\n\
                [-m|--max-events MAXEVENTS] [-p|--prescales] [-v|--verbose] [-h|--help]\n\
 \n\
   -o|--old-files FILE1.ROOT [FILE2.ROOT ...]\n\
       input file(s) with the old (reference) trigger results.\n\
 \n\
   -O|--old-process PROCESS\n\
       process name of the collection with the old (reference) trigger results;\n\
       the default is to take the 'TriggerResults' from the last process.\n\
 \n\
   -n|--new-files FILE1.ROOT [FILE2.ROOT ...]\n\
       input file(s) with the new trigger results to be compared with the reference;\n\
       to read these from a different collection in the same files as\n\
       the reference, use '-n -' and specify the collection with -N (see below).\n\
 \n\
   -N|--new-process PROCESS\n\
       process name of the collection with the new (reference) trigger results;\n\
       the default is to take the 'TriggerResults' from the last process.\n\
 \n\
   -m|--max-events MAXEVENTS\n\
       compare only the first MAXEVENTS events;\n\
       the default is to compare all the events in the original (reference) files.\n\
 \n\
   -p|--prescales\n\
       do not ignore differences caused by HLTPrescaler modules.\n\
 \n\
   -v|--verbose\n\
       be (more) verbose:\n\
       use once to print event-by-event comparison results;\n\
       use twice to print the trigger candidates of the affected filters;\n\
       use three times to print all the trigger candidates for the affected events.\n\
 \n\
   -h|--help\n\
       print this help message, and exit." << std::endl;
 }

Classes

Enumerations

Functions

Enumeration Type Documentation

Function Documentation