HLTrigReport Class Reference

#include <HLTrigReport.h>

Inheritance diagram for HLTrigReport:

Public Types
using	Accumulate = hltrigreport::Accumulate
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override
void	beginJob () override
void	beginRun (edm::Run const &, edm::EventSetup const &) override
const std::vector< std::string > &	datasetNames () const
void	endJob () override
void	endRun (edm::Run const &, edm::EventSetup const &) override
std::shared_ptr< Accumulate >	globalBeginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) const override
void	globalEndLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override
	HLTrigReport (const edm::ParameterSet &)
const std::vector< std::string > &	streamNames () const
	~HLTrigReport () override
Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::WatchRuns, edm::LuminosityBlockCache< hltrigreport::Accumulate > >
	EDAnalyzer ()=default
	EDAnalyzer (const EDAnalyzer &)=delete
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
const EDAnalyzer &	operator= (const EDAnalyzer &)=delete
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
bool	wantsInputProcessBlocks () const final
bool	wantsProcessBlocks () const final
Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
bool	wantsStreamLuminosityBlocks () const
bool	wantsStreamRuns () const
	~EDAnalyzerBase () 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)

Static Public Member Functions
static ReportEvery	decode (const std::string &value)
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Types
enum	ReportEvery {   NEVER = 0, EVERY_EVENT = 1, EVERY_LUMI = 2, EVERY_RUN = 3,   EVERY_JOB = 4 }

Private Member Functions
hltrigreport::Accumulate &	chooseAccumulate (edm::LuminosityBlockIndex index)
void	dumpReport (hltrigreport::Accumulate const &accumulate, std::string const &header=std::string()) const
bool	readAfterLumi () const
void	reset ()
void	updateConfigCache ()
void	updateService (Accumulate const &accumulate) const
bool	useLumiCache () const

Private Attributes
hltrigreport::Accumulate	accumulate_
bool	configured_
std::vector< std::vector< std::string > >	datasetContents_
std::vector< std::string >	datasetNames_
std::vector< std::vector< unsigned int > >	dsIndex_
std::vector< std::vector< unsigned int > >	hlIndex_
std::vector< std::string >	hlNames_
HLTConfigProvider	hltConfig_
const edm::InputTag	hlTriggerResults_
const edm::EDGetTokenT< edm::TriggerResults >	hlTriggerResultsToken_
bool	isCustomDatasets_
bool	isCustomStreams_
std::vector< int >	posL1s_
std::vector< int >	posPre_
unsigned int	refIndex_
std::string	refPath_
const double	refRate_
const ReportEvery	reportBy_
const ReportEvery	resetBy_
const ReportEvery	serviceBy_
std::vector< std::vector< std::string > >	streamContents_
std::vector< std::string >	streamNames_

Additional Inherited Members
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 ()
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)
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

See header file for documentation

Author

Martin Grunewald

This class is an EDAnalyzer implementing TrigReport (statistics printed to log file) for HL triggers

Author

Martin Grunewald

Definition at line 63 of file HLTrigReport.h.

Member Typedef Documentation

Accumulate

using HLTrigReport::Accumulate = hltrigreport::Accumulate

Definition at line 69 of file HLTrigReport.h.

Member Enumeration Documentation

ReportEvery

enum HLTrigReport::ReportEvery

private

Enumerator
NEVER
EVERY_EVENT
EVERY_LUMI
EVERY_RUN
EVERY_JOB

Definition at line 66 of file HLTrigReport.h.

{ NEVER = 0, EVERY_EVENT = 1, EVERY_LUMI = 2, EVERY_RUN = 3, EVERY_JOB = 4 };

Constructor & Destructor Documentation

HLTrigReport()

HLTrigReport::HLTrigReport ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 152 of file HLTrigReport.cc.

References datasetContents_, datasetNames_, edm::InputTag::encode(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNamesForType(), edm::ParameterSet::getUntrackedParameter(), hlTriggerResults_, isCustomDatasets_, isCustomStreams_, LogDebug, Skims_PA_cff::name, NEVER, refIndex_, refPath_, refRate_, serviceBy_, streamContents_, streamNames_, and AlCaHLTBitMon_QueryRunRegistry::string.

    : hlTriggerResults_(iConfig.getParameter<edm::InputTag>("HLTriggerResults")),
      hlTriggerResultsToken_(consumes<edm::TriggerResults>(hlTriggerResults_)),
      configured_(false),
      hlNames_(0),
      hlIndex_(0),
      posL1s_(0),
      posPre_(0),
      datasetNames_(0),
      datasetContents_(0),
      isCustomDatasets_(false),
      dsIndex_(0),
      streamNames_(0),
      streamContents_(0),
      isCustomStreams_(false),
      refPath_("HLTriggerFinalPath"),
      refIndex_(0),
      refRate_(iConfig.getUntrackedParameter<double>("ReferenceRate", 100.0)),
      reportBy_(decode(iConfig.getUntrackedParameter<std::string>("reportBy", "job"))),
      resetBy_(decode(iConfig.getUntrackedParameter<std::string>("resetBy", "never"))),
      serviceBy_(decode(iConfig.getUntrackedParameter<std::string>("serviceBy", "never"))),
      hltConfig_() {
  const edm::ParameterSet customDatasets(
      iConfig.getUntrackedParameter<edm::ParameterSet>("CustomDatasets", edm::ParameterSet()));
  isCustomDatasets_ = (customDatasets != edm::ParameterSet());
  if (isCustomDatasets_) {
    datasetNames_ = customDatasets.getParameterNamesForType<std::vector<std::string> >();
    for (std::vector<std::string>::const_iterator name = datasetNames_.begin(); name != datasetNames_.end(); name++) {
      datasetContents_.push_back(customDatasets.getParameter<std::vector<std::string> >(*name));
    }
  }

  const edm::ParameterSet customStreams(
      iConfig.getUntrackedParameter<edm::ParameterSet>("CustomStreams", edm::ParameterSet()));
  isCustomStreams_ = (customStreams != edm::ParameterSet());
  if (isCustomStreams_) {
    streamNames_ = customStreams.getParameterNamesForType<std::vector<std::string> >();
    for (std::vector<std::string>::const_iterator name = streamNames_.begin(); name != streamNames_.end(); name++) {
      streamContents_.push_back(customStreams.getParameter<std::vector<std::string> >(*name));
    }
  }

  refPath_ = iConfig.getUntrackedParameter<std::string>("ReferencePath", "HLTriggerFinalPath");
  refIndex_ = 0;

  LogDebug("HLTrigReport") << "HL TiggerResults: " + hlTriggerResults_.encode()
                           << " using reference path and rate: " + refPath_ + " " << refRate_;

  if (serviceBy_ != NEVER and edm::Service<HLTrigReportService>()) {
    edm::Service<HLTrigReportService>()->registerModule(this);
  }
}

~HLTrigReport()

HLTrigReport::~HLTrigReport ( )

overridedefault

Member Function Documentation

analyze()

void HLTrigReport::analyze ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 407 of file HLTrigReport.cc.

References accept(), edm::HLTGlobalStatus::accept(), chooseAccumulate(), configured_, dsIndex_, dumpReport(), edm::InputTag::encode(), edm::HLTGlobalStatus::error(), EVERY_EVENT, hlIndex_, hlNames_, hlTriggerResults_, hlTriggerResultsToken_, mps_fire::i, iEvent, caHitNtupletGeneratorKernels::if(), edm::HLTGlobalStatus::index(), edm::HandleBase::isValid(), LogDebug, dqmiodumpmetadata::n, or, AlCaHLTBitMon_ParallelJobs::p, posL1s_, posPre_, reportBy_, hltrigreport::Accumulate::reset(), resetBy_, alignCSCRings::s, serviceBy_, cms::cuda::stream, updateService(), and edm::HLTGlobalStatus::wasrun().

                                                                              {
  // accumulation of statistics event by event

  using namespace std;
  using namespace edm;

  auto& accumulate = chooseAccumulate(iEvent.getLuminosityBlock().index());
  if (resetBy_ == EVERY_EVENT) {
    //NOTE if we have reportBy == lumi/run/job then we will report the last
    // event in each lumi/run/job
    accumulate.reset();
  }

  accumulate.nEvents_++;

  // get hold of TriggerResults
  Handle<TriggerResults> HLTR;
  iEvent.getByToken(hlTriggerResultsToken_, HLTR);
  if (HLTR.isValid()) {
    if (HLTR->wasrun())
      accumulate.nWasRun_++;
    const bool accept(HLTR->accept());
    LogDebug("HLTrigReport") << "HLT TriggerResults decision: " << accept;
    if (accept)
      ++accumulate.nAccept_;
    if (HLTR->error())
      accumulate.nErrors_++;
  } else {
    LogDebug("HLTrigReport") << "HLT TriggerResults with label [" + hlTriggerResults_.encode() + "] not found!";
    accumulate.nErrors_++;
    return;
  }

  // HLTConfigProvider not configured - cannot produce any detailed statistics
  if (not configured_)
    return;

  // decision for each HL algorithm
  const unsigned int n(hlNames_.size());
  bool acceptedByPrevoiusPaths = false;
  for (unsigned int i = 0; i != n; ++i) {
    if (HLTR->wasrun(i))
      accumulate.hlWasRun_[i]++;
    if (HLTR->accept(i)) {
      acceptedByPrevoiusPaths = true;
      accumulate.hlAccept_[i]++;
    }
    if (acceptedByPrevoiusPaths)
      accumulate.hlAccTot_[i]++;
    if (HLTR->error(i))
      accumulate.hlErrors_[i]++;
    const int index(static_cast<int>(HLTR->index(i)));
    if (HLTR->accept(i)) {
      if (index >= posL1s_[i])
        accumulate.hltL1s_[i]++;
      if (index >= posPre_[i])
        accumulate.hltPre_[i]++;
    } else {
      if (index > posL1s_[i])
        accumulate.hltL1s_[i]++;
      if (index > posPre_[i])
        accumulate.hltPre_[i]++;
    }
  }

  // calculate accumulation of accepted events by a path within a dataset
  std::vector<bool> acceptedByDS(hlIndex_.size(), false);
  for (size_t ds = 0; ds < hlIndex_.size(); ++ds) {
    for (size_t p = 0; p < hlIndex_[ds].size(); ++p) {
      if (acceptedByDS[ds] or HLTR->accept(hlIndex_[ds][p])) {
        acceptedByDS[ds] = true;
        accumulate.hlAccTotDS_[ds][p]++;
      }
    }
    if (acceptedByDS[ds])
      accumulate.hlAllTotDS_[ds]++;
  }

  // calculate accumulation of accepted events by a dataset within a stream
  for (size_t s = 0; s < dsIndex_.size(); ++s) {
    bool acceptedByS = false;
    for (size_t ds = 0; ds < dsIndex_[s].size(); ++ds) {
      if (acceptedByS or acceptedByDS[dsIndex_[s][ds]]) {
        acceptedByS = true;
        accumulate.dsAccTotS_[s][ds]++;
      }
    }
    if (acceptedByS)
      accumulate.dsAllTotS_[s]++;
  }

  if (reportBy_ == EVERY_EVENT) {
    std::stringstream stream;
    stream << "Summary for Run " << iEvent.run() << ", LumiSection " << iEvent.luminosityBlock() << ", Event "
           << iEvent.id();
    dumpReport(accumulate, stream.str());
  }
  if (serviceBy_ == EVERY_EVENT) {
    updateService(accumulate);
  }
}

beginJob()

void HLTrigReport::beginJob ( void  )

overridevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 318 of file HLTrigReport.cc.

References EVERY_JOB, reset(), and resetBy_.

                            {
  if (resetBy_ == EVERY_JOB)
    reset();
}

beginRun()

void HLTrigReport::beginRun ( edm::Run const &  iRun, edm::EventSetup const &  iSetup  )

override

Definition at line 331 of file HLTrigReport.cc.

References hlx_dqm_sourceclient_cfi::Accumulate, accumulate_, configured_, dsIndex_, dumpReport(), EVERY_RUN, hlIndex_, hlNames_, hltConfig_, hlTriggerResults_, HLTConfigProvider::init(), edm::InputTag::process(), reset(), resetBy_, and updateConfigCache().

                                                                           {
  bool changed = true;
  if (hltConfig_.init(iRun, iSetup, hlTriggerResults_.process(), changed)) {
    configured_ = true;
    if (changed) {
      dumpReport(accumulate_, "Summary for this HLT table");
      updateConfigCache();
      accumulate_ = Accumulate(hlNames_.size(), hlIndex_, dsIndex_);
    }
  } else {
    dumpReport(accumulate_, "Summary for this HLT table");
    // cannot initialize the HLT menu - reset and clear all counters and tables
    configured_ = false;

    accumulate_ = hltrigreport::Accumulate();
  }

  if (resetBy_ == EVERY_RUN)
    reset();
}

chooseAccumulate()

hltrigreport::Accumulate& HLTrigReport::chooseAccumulate ( edm::LuminosityBlockIndex  index )

inlineprivate

Definition at line 96 of file HLTrigReport.h.

References accumulate_, and useLumiCache().

Referenced by analyze().

                                                                          {
    if (useLumiCache()) {
      return *luminosityBlockCache(index);
    }
    return accumulate_;
  }

datasetNames()

const std::vector< std::string > & HLTrigReport::datasetNames

(

)

const

Definition at line 228 of file HLTrigReport.cc.

References datasetNames_.

{ return datasetNames_; }

decode()

HLTrigReport::ReportEvery HLTrigReport::decode ( const std::string &  value )

static

Definition at line 24 of file HLTrigReport.cc.

References EVERY_EVENT, EVERY_JOB, EVERY_LUMI, EVERY_RUN, Exception, and NEVER.

                                                                   {
  if (value == "never")
    return NEVER;

  if (value == "job")
    return EVERY_JOB;

  if (value == "run")
    return EVERY_RUN;

  if (value == "lumi")
    return EVERY_LUMI;

  if (value == "event")
    return EVERY_EVENT;

  throw cms::Exception("Configuration") << "Invalid option value \"" << value
                                        << "\". Legal values are \"job\", \"run\", \"lumi\", \"event\" and \"never\".";
}

dumpReport()

void HLTrigReport::dumpReport ( hltrigreport::Accumulate const &  accumulate, std::string const &  header = std::string()  ) const

private

Definition at line 517 of file HLTrigReport.cc.

References simBeamSpotPI::alpha, configured_, datasetNames_, TauDecayModes::dec, hltrigreport::Accumulate::dsAccTotS_, hltrigreport::Accumulate::dsAllTotS_, dsIndex_, alignBH_cfg::fixed, RecoTauValidation_cfi::header, hltrigreport::Accumulate::hlAccept_, hltrigreport::Accumulate::hlAccTot_, hltrigreport::Accumulate::hlAccTotDS_, hltrigreport::Accumulate::hlAllTotDS_, hltrigreport::Accumulate::hlErrors_, hlIndex_, hlNames_, hltrigreport::Accumulate::hltL1s_, hltrigreport::Accumulate::hltPre_, hltrigreport::Accumulate::hlWasRun_, mps_fire::i, SiStripPI::max, dqmiodumpmetadata::n, hltrigreport::Accumulate::nAccept_, hltrigreport::Accumulate::nErrors_, hltrigreport::Accumulate::nEvents_, hltrigreport::Accumulate::nWasRun_, AlCaHLTBitMon_ParallelJobs::p, refIndex_, refRate_, alignCSCRings::s, pfClustersFromCombinedCaloHF_cfi::scale, and streamNames_.

Referenced by analyze(), beginRun(), endJob(), endRun(), and globalEndLuminosityBlock().

                                                               {
  // final printout of accumulated statistics

  using namespace std;
  using namespace edm;
  const unsigned int n(hlNames_.size());

  if ((n == 0) and (accumulate.nEvents_ == 0))
    return;

  LogVerbatim("HLTrigReport") << dec << endl;
  LogVerbatim("HLTrigReport") << "HLT-Report "
                              << "---------- Event  Summary ------------" << endl;
  if (not header.empty())
    LogVerbatim("HLTrigReport") << "HLT-Report " << header << endl;
  LogVerbatim("HLTrigReport") << "HLT-Report"
                              << " Events total = " << accumulate.nEvents_ << " wasrun = " << accumulate.nWasRun_
                              << " passed = " << accumulate.nAccept_ << " errors = " << accumulate.nErrors_ << endl;

  // HLTConfigProvider not configured - cannot produce any detailed statistics
  if (not configured_)
    return;

  double scale = accumulate.hlAccept_[refIndex_] > 0 ? refRate_ / accumulate.hlAccept_[refIndex_] : 0.;
  double alpha = 1 - (1.0 - .6854) / 2;  // for the Clopper-Pearson 68% CI

  LogVerbatim("HLTrigReport") << endl;
  LogVerbatim("HLTrigReport") << "HLT-Report "
                              << "---------- HLTrig Summary ------------" << endl;
  LogVerbatim("HLTrigReport") << "HLT-Report " << right << setw(7) << "HLT #"
                              << " " << right << setw(7) << "WasRun"
                              << " " << right << setw(7) << "L1S"
                              << " " << right << setw(7) << "Pre"
                              << " " << right << setw(7) << "HLT"
                              << " " << right << setw(9) << "%L1sPre"
                              << " " << right << setw(7) << "Rate"
                              << " " << right << setw(7) << "RateHi"
                              << " " << right << setw(7) << "Errors"
                              << " "
                              << "Name" << endl;

  if (n > 0) {
    for (unsigned int i = 0; i != n; ++i) {
      LogVerbatim("HLTrigReport")
          << "HLT-Report " << right << setw(7) << i << " " << right << setw(7) << accumulate.hlWasRun_[i] << " "
          << right << setw(7) << accumulate.hltL1s_[i] << " " << right << setw(7) << accumulate.hltPre_[i] << " "
          << right << setw(7) << accumulate.hlAccept_[i] << " " << right << setw(9) << fixed << setprecision(5)
          << static_cast<float>(100 * accumulate.hlAccept_[i]) / static_cast<float>(max(accumulate.hltPre_[i], 1u))
          << " " << right << setw(7) << fixed << setprecision(1) << scale * accumulate.hlAccept_[i] << " " << right
          << setw(7) << fixed << setprecision(1)
          << ((accumulate.hlAccept_[refIndex_] - accumulate.hlAccept_[i] > 0)
                  ? refRate_ * ROOT::Math::beta_quantile(alpha,
                                                         accumulate.hlAccept_[i] + 1,
                                                         accumulate.hlAccept_[refIndex_] - accumulate.hlAccept_[i])
                  : 0)
          << " " << right << setw(7) << accumulate.hlErrors_[i] << " " << hlNames_[i] << endl;
    }
  }

  LogVerbatim("HLTrigRprtTt") << endl;
  LogVerbatim("HLTrigRprtTt") << "HLT-Report "
                              << "---------- HLTrig Summary ------------" << endl;
  LogVerbatim("HLTrigRprtTt") << "HLT-Report " << right << setw(7) << "HLT #"
                              << " " << right << setw(7) << "WasRun"
                              << " " << right << setw(7) << "L1S"
                              << " " << right << setw(7) << "Pre"
                              << " " << right << setw(7) << "HLT"
                              << " " << right << setw(9) << "%L1sPre"
                              << " " << right << setw(7) << "Rate"
                              << " " << right << setw(7) << "RateHi"
                              << " " << right << setw(7) << "HLTtot"
                              << " " << right << setw(7) << "RateTot"
                              << " " << right << setw(7) << "Errors"
                              << " "
                              << "Name" << endl;

  if (n > 0) {
    for (unsigned int i = 0; i != n; ++i) {
      LogVerbatim("HLTrigRprtTt")
          << "HLT-Report " << right << setw(7) << i << " " << right << setw(7) << accumulate.hlWasRun_[i] << " "
          << right << setw(7) << accumulate.hltL1s_[i] << " " << right << setw(7) << accumulate.hltPre_[i] << " "
          << right << setw(7) << accumulate.hlAccept_[i] << " " << right << setw(9) << fixed << setprecision(5)
          << static_cast<float>(100 * accumulate.hlAccept_[i]) / static_cast<float>(max(accumulate.hltPre_[i], 1u))
          << " " << right << setw(7) << fixed << setprecision(1) << scale * accumulate.hlAccept_[i] << " " << right
          << setw(7) << fixed << setprecision(1)
          << ((accumulate.hlAccept_[refIndex_] - accumulate.hlAccept_[i] > 0)
                  ? refRate_ * ROOT::Math::beta_quantile(alpha,
                                                         accumulate.hlAccept_[i] + 1,
                                                         accumulate.hlAccept_[refIndex_] - accumulate.hlAccept_[i])
                  : 0)
          << " " << right << setw(7) << accumulate.hlAccTot_[i] << " " << right << setw(7) << fixed << setprecision(1)
          << scale * accumulate.hlAccTot_[i] << " " << right << setw(7) << accumulate.hlErrors_[i] << " " << hlNames_[i]
          << endl;
    }

    // now for each dataset
    for (size_t ds = 0; ds < hlIndex_.size(); ++ds) {
      LogVerbatim("HLTrigRprtPD") << endl;
      LogVerbatim("HLTrigRprtPD") << "HLT-Report "
                                  << "---------- Dataset Summary: " << datasetNames_[ds] << " ------------"
                                  << accumulate.hlAllTotDS_[ds] << endl;
      LogVerbatim("HLTrigRprtPD") << "HLT-Report " << right << setw(7) << "HLT #"
                                  << " " << right << setw(7) << "WasRun"
                                  << " " << right << setw(7) << "L1S"
                                  << " " << right << setw(7) << "Pre"
                                  << " " << right << setw(7) << "HLT"
                                  << " " << right << setw(9) << "%L1sPre"
                                  << " " << right << setw(7) << "Rate"
                                  << " " << right << setw(7) << "RateHi"
                                  << " " << right << setw(7) << "HLTtot"
                                  << " " << right << setw(7) << "RateTot"
                                  << " " << right << setw(7) << "Errors"
                                  << " "
                                  << "Name" << endl;
      for (size_t p = 0; p < hlIndex_[ds].size(); ++p) {
        LogVerbatim("HLTrigRprtPD")
            << "HLT-Report " << right << setw(7) << p << " " << right << setw(7)
            << accumulate.hlWasRun_[hlIndex_[ds][p]] << " " << right << setw(7) << accumulate.hltL1s_[hlIndex_[ds][p]]
            << " " << right << setw(7) << accumulate.hltPre_[hlIndex_[ds][p]] << " " << right << setw(7)
            << accumulate.hlAccept_[hlIndex_[ds][p]] << " " << right << setw(9) << fixed << setprecision(5)
            << static_cast<float>(100 * accumulate.hlAccept_[hlIndex_[ds][p]]) /
                   static_cast<float>(max(accumulate.hltPre_[hlIndex_[ds][p]], 1u))
            << " " << right << setw(7) << fixed << setprecision(1) << scale * accumulate.hlAccept_[hlIndex_[ds][p]]
            << " " << right << setw(7) << fixed << setprecision(1)
            << ((accumulate.hlAccept_[refIndex_] - accumulate.hlAccept_[hlIndex_[ds][p]] > 0)
                    ? refRate_ * ROOT::Math::beta_quantile(
                                     alpha,
                                     accumulate.hlAccept_[hlIndex_[ds][p]] + 1,
                                     accumulate.hlAccept_[refIndex_] - accumulate.hlAccept_[hlIndex_[ds][p]])
                    : 0)
            << " " << right << setw(7) << accumulate.hlAccTotDS_[ds][p] << " " << right << setw(7) << fixed
            << setprecision(1) << scale * accumulate.hlAccTotDS_[ds][p] << " " << right << setw(7)
            << accumulate.hlErrors_[hlIndex_[ds][p]] << " " << hlNames_[hlIndex_[ds][p]] << endl;
      }
    }

    // now for each stream
    for (size_t s = 0; s < dsIndex_.size(); ++s) {
      LogVerbatim("HLTrigRprtST") << endl;
      LogVerbatim("HLTrigRprtST") << "HLT-Report "
                                  << "---------- Stream Summary: " << streamNames_[s] << " ------------"
                                  << accumulate.dsAllTotS_[s] << endl;
      LogVerbatim("HLTrigRprtST") << "HLT-Report " << right << setw(10) << "Dataset #"
                                  << " " << right << setw(10) << "Individual"
                                  << " " << right << setw(10) << "Total"
                                  << " " << right << setw(10) << "Rate"
                                  << " " << right << setw(10) << "RateHi"
                                  << " " << right << setw(10) << "RateTot"
                                  << " "
                                  << "Name" << endl;
      for (size_t ds = 0; ds < dsIndex_[s].size(); ++ds) {
        unsigned int acceptedDS = accumulate.hlAccTotDS_[dsIndex_[s][ds]][hlIndex_[dsIndex_[s][ds]].size() - 1];
        LogVerbatim("HLTrigRprtST")
            << "HLT-Report " << right << setw(10) << ds << " " << right << setw(10) << acceptedDS << " " << right
            << setw(10) << accumulate.dsAccTotS_[s][ds] << " " << right << setw(10) << fixed << setprecision(1)
            << scale * acceptedDS << " " << right << setw(10) << fixed << setprecision(1)
            << ((accumulate.hlAccept_[refIndex_] - acceptedDS > 0)
                    ? refRate_ *
                          ROOT::Math::beta_quantile(alpha, acceptedDS + 1, accumulate.hlAccept_[refIndex_] - acceptedDS)
                    : 0)
            << " " << right << setw(10) << fixed << setprecision(1) << scale * accumulate.dsAccTotS_[s][ds] << " "
            << datasetNames_[dsIndex_[s][ds]] << endl;
      }
    }

  } else {
    LogVerbatim("HLTrigReport") << "HLT-Report - No HLT paths found!" << endl;
  }

  LogVerbatim("HLTrigReport") << endl;
  LogVerbatim("HLTrigReport") << "HLT-Report end!" << endl;
  LogVerbatim("HLTrigReport") << endl;

  return;
}

endJob()

void HLTrigReport::endJob ( void  )

overridevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 323 of file HLTrigReport.cc.

References accumulate_, dumpReport(), EVERY_JOB, reportBy_, serviceBy_, and updateService().

                          {
  if (reportBy_ == EVERY_JOB)
    dumpReport(accumulate_, "Summary for Job");
  if (serviceBy_ == EVERY_JOB) {
    updateService(accumulate_);
  }
}

endRun()

void HLTrigReport::endRun ( edm::Run const &  run, edm::EventSetup const &  setup  )

override

Definition at line 352 of file HLTrigReport.cc.

References accumulate_, dumpReport(), EVERY_RUN, reportBy_, writedatasetfile::run, serviceBy_, cms::cuda::stream, and updateService().

                                                                       {
  if (reportBy_ == EVERY_RUN) {
    std::stringstream stream;
    stream << "Summary for Run " << run.run();
    dumpReport(accumulate_, stream.str());
  }
  if (serviceBy_ == EVERY_RUN) {
    updateService(accumulate_);
  }
}

fillDescriptions()

void HLTrigReport::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 207 of file HLTrigReport.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                              {
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("HLTriggerResults", edm::InputTag("TriggerResults", "", "HLT"));
  desc.addUntracked<std::string>("reportBy", "job");
  desc.addUntracked<std::string>("resetBy", "never");
  desc.addUntracked<std::string>("serviceBy", "never");

  edm::ParameterSetDescription customDatasetsParameters;
  desc.addUntracked<edm::ParameterSetDescription>("CustomDatasets", customDatasetsParameters);
  edm::ParameterSetDescription customStreamsParameters;
  desc.addUntracked<edm::ParameterSetDescription>("CustomStreams", customStreamsParameters);
  desc.addUntracked<std::string>("ReferencePath", "HLTriggerFinalPath");
  desc.addUntracked<double>("ReferenceRate", 100.0);

  descriptions.add("hltTrigReport", desc);
}

globalBeginLuminosityBlock()

std::shared_ptr< HLTrigReport::Accumulate > HLTrigReport::globalBeginLuminosityBlock ( edm::LuminosityBlock const &  lumi, edm::EventSetup const &  setup  ) const

override

Definition at line 363 of file HLTrigReport.cc.

References configured_, dsIndex_, hlIndex_, hlNames_, and useLumiCache().

                                                                                                                     {
  if (useLumiCache()) {
    if (not configured_) {
      return std::make_shared<Accumulate>();
    }
    return std::make_shared<Accumulate>(hlNames_.size(), hlIndex_, dsIndex_);
  }
  return std::shared_ptr<Accumulate>();
}

globalEndLuminosityBlock()

void HLTrigReport::globalEndLuminosityBlock ( edm::LuminosityBlock const &  lumi, edm::EventSetup const &  setup  )

override

Definition at line 374 of file HLTrigReport.cc.

References hltrigreport::Accumulate::accumulate(), accumulate_, dumpReport(), EVERY_EVENT, EVERY_JOB, EVERY_LUMI, EVERY_RUN, eostools::move(), NEVER, or, readAfterLumi(), reportBy_, resetBy_, serviceBy_, cms::cuda::stream, updateService(), and useLumiCache().

                                                                                                      {
  if (not useLumiCache()) {
    return;
  }

  if (resetBy_ == EVERY_LUMI and readAfterLumi()) {
    //we will be reporting the last processed lumi
    accumulate_ = std::move(*luminosityBlockCache(lumi.index()));
  } else if (resetBy_ == NEVER or resetBy_ == EVERY_RUN or resetBy_ == EVERY_JOB or readAfterLumi()) {
    //we need to add this lumi's info to the longer lived accumulation
    accumulate_.accumulate(*luminosityBlockCache(lumi.index()));
  }

  if (reportBy_ == EVERY_LUMI) {
    std::stringstream stream;
    stream << "Summary for Run " << lumi.run() << ", LumiSection " << lumi.luminosityBlock();
    if (resetBy_ == EVERY_LUMI or resetBy_ == EVERY_EVENT) {
      dumpReport(*luminosityBlockCache(lumi.index()), stream.str());
    } else {
      dumpReport(accumulate_, stream.str());
    }
  }

  if (serviceBy_ == EVERY_LUMI) {
    if (resetBy_ == EVERY_LUMI or resetBy_ == EVERY_EVENT) {
      updateService(*luminosityBlockCache(lumi.index()));
    } else {
      updateService(accumulate_);
    }
  }
}

readAfterLumi()

bool HLTrigReport::readAfterLumi ( ) const

inlineprivate

Definition at line 103 of file HLTrigReport.h.

References EVERY_JOB, EVERY_RUN, or, reportBy_, and serviceBy_.

Referenced by globalEndLuminosityBlock().

                             {
    return (reportBy_ == EVERY_RUN or reportBy_ == EVERY_JOB or serviceBy_ == EVERY_RUN or serviceBy_ == EVERY_JOB);
  }

reset()

void HLTrigReport::reset ( void  )

private

Definition at line 316 of file HLTrigReport.cc.

References accumulate_, and hltrigreport::Accumulate::reset().

Referenced by beginJob(), and beginRun().

{ accumulate_.reset(); }

streamNames()

const std::vector< std::string > & HLTrigReport::streamNames

(

)

const

Definition at line 229 of file HLTrigReport.cc.

References streamNames_.

{ return streamNames_; }

updateConfigCache()

void HLTrigReport::updateConfigCache ( )

private

Definition at line 231 of file HLTrigReport.cc.

References HLTConfigProvider::datasetContents(), datasetContents_, HLTConfigProvider::datasetNames(), datasetNames_, dsIndex_, hlIndex_, hlNames_, hltConfig_, mps_fire::i, isCustomDatasets_, isCustomStreams_, dqmiolumiharvest::j, label, HLTConfigProvider::moduleLabels(), HLTConfigProvider::moduleType(), dqmiodumpmetadata::n, NEVER, AlCaHLTBitMon_ParallelJobs::p, posL1s_, posPre_, refIndex_, refPath_, alignCSCRings::s, serviceBy_, findQualityFiles::size, HLTConfigProvider::streamContents(), streamContents_, HLTConfigProvider::streamNames(), streamNames_, AlCaHLTBitMon_QueryRunRegistry::string, HLTConfigProvider::triggerIndex(), and HLTConfigProvider::triggerNames().

Referenced by beginRun().

                                     {
  // update trigger names
  hlNames_ = hltConfig_.triggerNames();

  const unsigned int n = hlNames_.size();

  // find the positions of seeding and prescaler modules
  posL1s_.resize(n);
  posPre_.resize(n);
  for (unsigned int i = 0; i < n; ++i) {
    posL1s_[i] = -1;
    posPre_[i] = -1;
    const std::vector<std::string>& moduleLabels(hltConfig_.moduleLabels(i));
    for (unsigned int j = 0; j < moduleLabels.size(); ++j) {
      const std::string& label = hltConfig_.moduleType(moduleLabels[j]);
      if (label == "HLTLevel1GTSeed")
        posL1s_[i] = j;
      else if (label == "HLTPrescaler")
        posPre_[i] = j;
    }
  }

  // if not overridden, reload the datasets and streams
  if (not isCustomDatasets_) {
    datasetNames_ = hltConfig_.datasetNames();
    datasetContents_ = hltConfig_.datasetContents();
  }
  if (not isCustomStreams_) {
    streamNames_ = hltConfig_.streamNames();
    streamContents_ = hltConfig_.streamContents();
  }

  // fill the matrices of hlIndex_, hlAccTotDS_
  hlIndex_.clear();
  hlIndex_.resize(datasetNames_.size());
  for (unsigned int ds = 0; ds < datasetNames_.size(); ds++) {
    unsigned int size = datasetContents_[ds].size();
    hlIndex_[ds].reserve(size);
    for (unsigned int p = 0; p < size; ++p) {
      unsigned int i = hltConfig_.triggerIndex(datasetContents_[ds][p]);
      if (i < n) {
        hlIndex_[ds].push_back(i);
      }
    }
  }

  // fill the matrices of dsIndex_, dsAccTotS_
  dsIndex_.clear();
  dsIndex_.resize(streamNames_.size());
  for (unsigned int s = 0; s < streamNames_.size(); ++s) {
    unsigned int size = streamContents_[s].size();
    dsIndex_.reserve(size);
    for (unsigned int ds = 0; ds < size; ++ds) {
      unsigned int i = 0;
      for (; i < datasetNames_.size(); i++)
        if (datasetNames_[i] == streamContents_[s][ds])
          break;
      // report only datasets that have at least one path otherwise crash
      if (i < datasetNames_.size() and !hlIndex_[i].empty()) {
        dsIndex_[s].push_back(i);
      }
    }
  }

  // if needed, update the reference path
  refIndex_ = hltConfig_.triggerIndex(refPath_);
  if (refIndex_ >= n) {
    refIndex_ = 0;
    edm::LogWarning("HLTrigReport") << "Requested reference path '" + refPath_ + "' not in HLT menu. "
                                    << "Using HLTriggerFinalPath instead.";
    refPath_ = "HLTriggerFinalPath";
    refIndex_ = hltConfig_.triggerIndex(refPath_);
    if (refIndex_ >= n) {
      refIndex_ = 0;
      edm::LogWarning("HLTrigReport") << "Requested reference path '" + refPath_ + "' not in HLT menu. "
                                      << "Using first path in table (index=0) instead.";
    }
  }

  if (serviceBy_ != NEVER and edm::Service<HLTrigReportService>()) {
    edm::Service<HLTrigReportService>()->setDatasetNames(datasetNames_);
    edm::Service<HLTrigReportService>()->setStreamNames(streamNames_);
  }
}

updateService()

void HLTrigReport::updateService ( Accumulate const &  accumulate ) const

private

Definition at line 509 of file HLTrigReport.cc.

References hltrigreport::Accumulate::dsAllTotS_, hltrigreport::Accumulate::hlAllTotDS_, and alignCSCRings::s.

Referenced by analyze(), endJob(), endRun(), and globalEndLuminosityBlock().

                                                                   {
  edm::Service<HLTrigReportService> s;
  if (s) {
    s->setDatasetCounts(accumulate.hlAllTotDS_);
    s->setStreamCounts(accumulate.dsAllTotS_);
  }
}

useLumiCache()

bool HLTrigReport::useLumiCache ( ) const

inlineprivate

Definition at line 102 of file HLTrigReport.h.

References EVERY_LUMI, or, reportBy_, resetBy_, and serviceBy_.

Referenced by chooseAccumulate(), globalBeginLuminosityBlock(), and globalEndLuminosityBlock().

{ return reportBy_ == EVERY_LUMI or serviceBy_ == EVERY_LUMI or resetBy_ == EVERY_LUMI; }

Member Data Documentation

accumulate_

hltrigreport::Accumulate HLTrigReport::accumulate_

private

Definition at line 141 of file HLTrigReport.h.

Referenced by beginRun(), chooseAccumulate(), endJob(), endRun(), globalEndLuminosityBlock(), and reset().

configured_

bool HLTrigReport::configured_

private

Definition at line 114 of file HLTrigReport.h.

Referenced by analyze(), beginRun(), dumpReport(), and globalBeginLuminosityBlock().

datasetContents_

std::vector<std::vector<std::string> > HLTrigReport::datasetContents_

private

Definition at line 125 of file HLTrigReport.h.

Referenced by HLTrigReport(), and updateConfigCache().

datasetNames_

std::vector<std::string> HLTrigReport::datasetNames_

private

Definition at line 124 of file HLTrigReport.h.

Referenced by datasetNames(), dumpReport(), HLTrigReport(), and updateConfigCache().

dsIndex_

std::vector<std::vector<unsigned int> > HLTrigReport::dsIndex_

private

Definition at line 128 of file HLTrigReport.h.

Referenced by analyze(), beginRun(), dumpReport(), globalBeginLuminosityBlock(), and updateConfigCache().

hlIndex_

std::vector<std::vector<unsigned int> > HLTrigReport::hlIndex_

private

Definition at line 119 of file HLTrigReport.h.

Referenced by analyze(), beginRun(), dumpReport(), globalBeginLuminosityBlock(), and updateConfigCache().

hlNames_

std::vector<std::string> HLTrigReport::hlNames_

private

Definition at line 116 of file HLTrigReport.h.

Referenced by analyze(), beginRun(), dumpReport(), globalBeginLuminosityBlock(), and updateConfigCache().

hltConfig_

HLTConfigProvider HLTrigReport::hltConfig_

private

Definition at line 139 of file HLTrigReport.h.

Referenced by beginRun(), and updateConfigCache().

hlTriggerResults_

const edm::InputTag HLTrigReport::hlTriggerResults_

private

Definition at line 112 of file HLTrigReport.h.

Referenced by analyze(), beginRun(), and HLTrigReport().

hlTriggerResultsToken_

const edm::EDGetTokenT<edm::TriggerResults> HLTrigReport::hlTriggerResultsToken_

private

Definition at line 113 of file HLTrigReport.h.

Referenced by analyze().

isCustomDatasets_

bool HLTrigReport::isCustomDatasets_

private

Definition at line 126 of file HLTrigReport.h.

Referenced by HLTrigReport(), and updateConfigCache().

isCustomStreams_

bool HLTrigReport::isCustomStreams_

private

Definition at line 131 of file HLTrigReport.h.

Referenced by HLTrigReport(), and updateConfigCache().

posL1s_

std::vector<int> HLTrigReport::posL1s_

private

Definition at line 121 of file HLTrigReport.h.

Referenced by analyze(), and updateConfigCache().

posPre_

std::vector<int> HLTrigReport::posPre_

private

Definition at line 122 of file HLTrigReport.h.

Referenced by analyze(), and updateConfigCache().

refIndex_

unsigned int HLTrigReport::refIndex_

private

Definition at line 133 of file HLTrigReport.h.

Referenced by dumpReport(), HLTrigReport(), and updateConfigCache().

refPath_

std::string HLTrigReport::refPath_

private

Definition at line 132 of file HLTrigReport.h.

Referenced by HLTrigReport(), and updateConfigCache().

refRate_

const double HLTrigReport::refRate_

private

Definition at line 134 of file HLTrigReport.h.

Referenced by dumpReport(), and HLTrigReport().

reportBy_

const ReportEvery HLTrigReport::reportBy_

private

Definition at line 136 of file HLTrigReport.h.

Referenced by analyze(), endJob(), endRun(), globalEndLuminosityBlock(), readAfterLumi(), and useLumiCache().

resetBy_

const ReportEvery HLTrigReport::resetBy_

private

Definition at line 137 of file HLTrigReport.h.

Referenced by analyze(), beginJob(), beginRun(), globalEndLuminosityBlock(), and useLumiCache().

serviceBy_

const ReportEvery HLTrigReport::serviceBy_

private

Definition at line 138 of file HLTrigReport.h.

Referenced by analyze(), endJob(), endRun(), globalEndLuminosityBlock(), HLTrigReport(), readAfterLumi(), updateConfigCache(), and useLumiCache().

streamContents_

std::vector<std::vector<std::string> > HLTrigReport::streamContents_

private

Definition at line 130 of file HLTrigReport.h.

Referenced by HLTrigReport(), and updateConfigCache().

streamNames_

std::vector<std::string> HLTrigReport::streamNames_

private

Definition at line 129 of file HLTrigReport.h.

Referenced by dumpReport(), HLTrigReport(), streamNames(), and updateConfigCache().