Inheritance diagram for LogErrorEventFilter:

Classes
struct	ErrorSort

Public Member Functions
virtual void	beginLuminosityBlock (const edm::LuminosityBlock &lumi, const edm::EventSetup &iSetup) override

virtual void	beginRun (const edm::Run &run, const edm::EventSetup &iSetup) override

virtual void	endJob () override

virtual void	endLuminosityBlock (const edm::LuminosityBlock &lumi, const edm::EventSetup &iSetup) override

virtual void	endLuminosityBlockProduce (edm::LuminosityBlock &lumi, const edm::EventSetup &iSetup) override

virtual void	endRun (const edm::Run &run, const edm::EventSetup &iSetup) override

virtual bool	filter (edm::Event &iEvent, const edm::EventSetup &iSetup) override

	LogErrorEventFilter (const edm::ParameterSet &iConfig)

virtual	~LogErrorEventFilter ()

Public Member Functions inherited from edm::one::EDFilter< edm::one::WatchRuns, edm::one::WatchLuminosityBlocks, edm::EndLuminosityBlockProducer >
	EDFilter ()=default

Public Member Functions inherited from edm::one::EDFilterBase
	EDFilterBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDFilterBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Types
typedef edm::ErrorSummaryEntry	Error

typedef std::vector < edm::ErrorSummaryEntry >	ErrorList

typedef std::set < edm::ErrorSummaryEntry, ErrorSort >	ErrorSet

Static Private Member Functions
template<typename Collection >
static void	increment (ErrorSet &scoreboard, Collection &list)

template<typename Collection >
static void	print (const Collection &errors)

static std::auto_ptr< ErrorList >	serialize (const ErrorSet &set)

Private Attributes
std::set< std::string >	categoriesToIgnore_

std::set< std::string >	categoriesToWatch_

ErrorSet	errorCollectionAll_

ErrorSet	errorCollectionThisLumi_

ErrorSet	errorCollectionThisRun_

bool	forcedValue_

size_t	maxSavedEventsPerLumi_

std::set< std::string >	modulesToIgnore_

std::set< std::string >	modulesToWatch_

size_t	nfailLumi_

size_t	nfailRun_

size_t	npassLumi_

size_t	npassRun_

bool	readSummaryMode_

edm::InputTag	src_

edm::EDGetTokenT< ErrorList >	srcT_

std::map< std::pair< uint32_t, uint32_t >, std::pair< size_t, size_t > >	statsPerLumi_

std::map< uint32_t, std::pair < size_t, size_t > >	statsPerRun_

bool	taggedMode_

double	thresholdPerLumi_

double	thresholdPerRun_

bool	verbose_

bool	veryVerbose_

Additional Inherited Members
Public Types inherited from edm::one::EDFilterBase
typedef EDFilterBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::one::EDFilterBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

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 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)

Detailed Description

Definition at line 33 of file LogErrorEventFilter.cc.

Member Typedef Documentation

typedef edm::ErrorSummaryEntry LogErrorEventFilter::Error

private

Definition at line 49 of file LogErrorEventFilter.cc.

typedef std::vector<edm::ErrorSummaryEntry> LogErrorEventFilter::ErrorList

private

Definition at line 58 of file LogErrorEventFilter.cc.

typedef std::set<edm::ErrorSummaryEntry,ErrorSort> LogErrorEventFilter::ErrorSet

private

Definition at line 59 of file LogErrorEventFilter.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 88 of file LogErrorEventFilter.cc.

References MillePedeFileConverter_cfg::categories, categoriesToIgnore_, categoriesToWatch_, edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), edmConvertToStreamModule::modules, modulesToIgnore_, and modulesToWatch_.

                                                                         :
     src_(iConfig.getParameter<edm::InputTag>("src")),
     srcT_(consumes<ErrorList>(iConfig.getParameter<edm::InputTag>("src"))),
     readSummaryMode_(iConfig.existsAs<bool>("readSummaryMode") ? iConfig.getParameter<bool>("readSummaryMode") : false),
     thresholdPerLumi_(iConfig.getParameter<double>("maxErrorFractionInLumi")),
     thresholdPerRun_(iConfig.getParameter<double>("maxErrorFractionInRun")),
     maxSavedEventsPerLumi_(iConfig.getParameter<uint32_t>("maxSavedEventsPerLumiAndError")),
     verbose_(iConfig.getUntrackedParameter<bool>("verbose", false)),
     veryVerbose_(iConfig.getUntrackedParameter<bool>("veryVerbose", false)),
     taggedMode_(iConfig.getUntrackedParameter<bool>("taggedMode", false)),
     forcedValue_(iConfig.getUntrackedParameter<bool>("forcedValue", true))
 {
     produces<ErrorList, edm::InLumi>();
     produces<int, edm::InLumi>("pass");
     produces<int, edm::InLumi>("fail");
     //produces<ErrorList, edm::InRun>();
     produces<bool>();
 
     if (iConfig.existsAs<std::vector<std::string> >("modulesToWatch")) {
         std::vector<std::string> modules = iConfig.getParameter<std::vector<std::string> >("modulesToWatch");
         if (!(modules.size() == 1 && modules[0] == "*")) {
             modulesToWatch_.insert(modules.begin(), modules.end());
         }
     }
     if (iConfig.existsAs<std::vector<std::string> >("modulesToIgnore")) {
         std::vector<std::string> modules = iConfig.getParameter<std::vector<std::string> >("modulesToIgnore");
         if (!(modules.size() == 1 && modules[0] == "*")) {
             modulesToIgnore_.insert(modules.begin(), modules.end());
         }
     }
     if (iConfig.existsAs<std::vector<std::string> >("categoriesToWatch")) {
         std::vector<std::string> categories = iConfig.getParameter<std::vector<std::string> >("categoriesToWatch");
         if (!(categories.size() == 1 && categories[0] == "*")) {
             categoriesToWatch_.insert(categories.begin(), categories.end());
         }
     }
     if (iConfig.existsAs<std::vector<std::string> >("categoriesToIgnore")) {
         std::vector<std::string> categories = iConfig.getParameter<std::vector<std::string> >("categoriesToIgnore");
         if (!(categories.size() == 1 && categories[0] == "*")) {
             categoriesToIgnore_.insert(categories.begin(), categories.end());
         }
     }
     //std::ostream_iterator<std::string> dump(std::cout, ", ");
     //std::cout << "\nWatch modules:     " ; std::copy(modulesToWatch_.begin(),     modulesToWatch_.end(),     dump);
     //std::cout << "\nIgnore modules:    " ; std::copy(modulesToIgnore_.begin(),    modulesToIgnore_.end(),    dump);
     //std::cout << "\nIgnore categories: " ; std::copy(categoriesToIgnore_.begin(), categoriesToIgnore_.end(), dump);
     //std::cout << "\nWatch categories:  " ; std::copy(categoriesToWatch_.begin(),  categoriesToWatch_.end(),  dump);
     //std::cout << std::endl;
 
 }

virtual LogErrorEventFilter::~LogErrorEventFilter ( )

inlinevirtual

Definition at line 38 of file LogErrorEventFilter.cc.

38 { }

Member Function Documentation

void LogErrorEventFilter::beginLuminosityBlock	(	const edm::LuminosityBlock &	lumi,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Definition at line 140 of file LogErrorEventFilter.cc.

References errorCollectionThisLumi_, edm::LuminosityBlock::getByLabel(), patZpeak::handle, increment(), edm::InputTag::label(), nfailLumi_, nfailRun_, npassLumi_, npassRun_, edm::InputTag::process(), readSummaryMode_, and src_.

                                                                                                      {
     npassLumi_ = 0; nfailLumi_ = 0;
     errorCollectionThisLumi_.clear();
     if (readSummaryMode_) {
         edm::Handle<ErrorList> handle;
         edm::Handle<int> hpass, hfail;
         lumi.getByLabel(src_, handle);
         lumi.getByLabel(edm::InputTag(src_.label(), "pass", src_.process()), hpass);
         lumi.getByLabel(edm::InputTag(src_.label(), "fail", src_.process()), hfail);
         increment(errorCollectionThisLumi_, *handle);
         npassLumi_ = *hpass;
         nfailLumi_ = *hfail;
         npassRun_ += npassLumi_;
         nfailRun_ += nfailLumi_;
     }
 }

void LogErrorEventFilter::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Definition at line 179 of file LogErrorEventFilter.cc.

References errorCollectionThisRun_, nfailRun_, and npassRun_.

                                                                             {
     npassRun_ = 0; nfailRun_ = 0;
     errorCollectionThisRun_.clear();
 }

void LogErrorEventFilter::endJob ( void )

overridevirtual

Reimplemented from edm::one::EDFilterBase.

Definition at line 200 of file LogErrorEventFilter.cc.

References counter, gather_cfg::cout, errorCollectionAll_, funct::fract(), print(), statsPerLumi_, statsPerRun_, thresholdPerLumi_, thresholdPerRun_, and verbose_.

                             {
     if (verbose_) {
         std::cout << "\n === REPORT FOR JOB === " << std::endl;
         print(errorCollectionAll_);
         
         typedef std::pair<size_t,size_t> counter;
 
         std::cout << "\n === SCOREBOARD PER RUN === " << std::endl;
         typedef std::pair<uint32_t, counter> hitRun;
         foreach(const hitRun &hit, statsPerRun_) {
             double fract = hit.second.second/double(hit.second.first + hit.second.second);
             printf("run %6d: fail %7zu, pass %7zu, fraction %7.3f%%%s\n", hit.first, hit.second.second, hit.second.first, fract*100., (fract >= thresholdPerRun_ ? " (run excluded from summary list)" : ""));
         }
  
         std::cout << "\n === SCOREBOARD PER LUMI === " << std::endl;
         typedef std::pair<std::pair<uint32_t,uint32_t>, counter> hitLumi;
         foreach(const hitLumi &hit, statsPerLumi_) {
             double fract = hit.second.second/double(hit.second.first + hit.second.second);
             printf("run %6d, lumi %4d: fail %zu, pass %zu, fraction %7.3f%%%s\n", hit.first.first, hit.first.second, hit.second.second, hit.second.first, fract*100., (fract >= thresholdPerLumi_ ? " (lumi excluded from run list)" : ""));
         }
     }
 }

void LogErrorEventFilter::endLuminosityBlock	(	const edm::LuminosityBlock &	lumi,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Definition at line 157 of file LogErrorEventFilter.cc.

References gather_cfg::cout, errorCollectionThisLumi_, errorCollectionThisRun_, increment(), edm::LuminosityBlockBase::luminosityBlock(), nfailLumi_, npassLumi_, print(), edm::LuminosityBlockBase::run(), statsPerLumi_, thresholdPerLumi_, and verbose_.

                                                                                                    {
    statsPerLumi_[std::pair<uint32_t,uint32_t>(lumi.run(), lumi.luminosityBlock())] = std::pair<size_t,size_t>(npassLumi_, nfailLumi_);
    if (nfailLumi_ < thresholdPerLumi_*(npassLumi_+nfailLumi_)) {
        increment(errorCollectionThisRun_, errorCollectionThisLumi_);
    }
    if (verbose_) {
        if (!errorCollectionThisLumi_.empty()) {
            std::cout << "\n === REPORT FOR RUN " << lumi.run() << " LUMI " << lumi.luminosityBlock() << " === " << std::endl;
            print(errorCollectionThisLumi_);
        }
    }
 }

void LogErrorEventFilter::endLuminosityBlockProduce	(	edm::LuminosityBlock &	lumi,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Definition at line 171 of file LogErrorEventFilter.cc.

References errorCollectionThisLumi_, nfailLumi_, npassLumi_, edm::LuminosityBlock::put(), and serialize().

                                                                                                     {
     lumi.put(serialize(errorCollectionThisLumi_));
     std::auto_ptr<int> outpass(new int(npassLumi_)); lumi.put(outpass, "pass");
     std::auto_ptr<int> outfail(new int(nfailLumi_)); lumi.put(outfail, "fail");
 }

void LogErrorEventFilter::endRun	(	const edm::Run &	run,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Definition at line 185 of file LogErrorEventFilter.cc.

References gather_cfg::cout, errorCollectionAll_, errorCollectionThisRun_, increment(), nfailRun_, npassRun_, print(), edm::RunBase::run(), statsPerRun_, thresholdPerRun_, and verbose_.

                                                                           {
     statsPerRun_[run.run()] = std::pair<size_t,size_t>(npassRun_, nfailRun_);
     if (nfailRun_ < thresholdPerRun_*(npassRun_+nfailRun_)) {
         increment(errorCollectionAll_, errorCollectionThisRun_);
     }
     if (verbose_) {
         if (!errorCollectionThisRun_.empty()) {
             std::cout << "\n === REPORT FOR RUN " << run.run() << " === " << std::endl;
             print(errorCollectionThisRun_);
         }
     }
     //run.put(serialize(errorCollectionThisRun_));
 }

bool LogErrorEventFilter::filter	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Implements edm::one::EDFilterBase.

Definition at line 224 of file LogErrorEventFilter.cc.

References categoriesToIgnore_, categoriesToWatch_, edm::ErrorSummaryEntry::category, edm::ErrorSummaryEntry::count, gather_cfg::cout, errorCollectionThisLumi_, benchmark_cfg::errors, edm::EventID::event(), cmsPerfPublish::fail(), forcedValue_, edm::Event::getByToken(), edm::EventBase::id(), citk::if(), edm::EventBase::luminosityBlock(), maxSavedEventsPerLumi_, edm::ErrorSummaryEntry::module, modulesToIgnore_, modulesToWatch_, nfailLumi_, nfailRun_, npassLumi_, npassRun_, print(), edm::Event::put(), readSummaryMode_, query::result, edm::Event::run(), cuy::save, srcT_, taggedMode_, and veryVerbose_.

Referenced by Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::filter(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::find(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::setDataAccessor(), and Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::switchCenterView().

                                                                            {
     if (readSummaryMode_) return true;
 
     bool fail = false, save = false;
 
     edm::Handle<ErrorList> errors;
     iEvent.getByToken(srcT_, errors);
 
    
     if (errors->empty()) { 
         npassRun_++; npassLumi_++;
     iEvent.put( std::auto_ptr<bool>(new bool(false)) );
 
     if(taggedMode_) return forcedValue_;
         return false;
     } 
 
     foreach (const Error &err, *errors) {
         if (!modulesToWatch_.empty()     && (modulesToWatch_.count(err.module)       == 0)) continue;
         if (!categoriesToWatch_.empty()  && (categoriesToWatch_.count(err.category)  == 0)) continue;
         if (!modulesToIgnore_.empty()    && (modulesToIgnore_.count(err.module)      != 0)) continue;
         if (!categoriesToIgnore_.empty() && (categoriesToIgnore_.count(err.category) != 0)) continue;
         
         fail = true;
         std::pair<ErrorSet::iterator, bool> result = errorCollectionThisLumi_.insert(err);
         if (!result.second) { // already there
             // need the const_cast as set elements are const
             const_cast<unsigned int &>(result.first->count) += err.count;
             if (result.first->count < maxSavedEventsPerLumi_) save = true;
         } else {
             save = true;
         }
         
     }
     if (save && veryVerbose_) {
         std::cout << "\n === REPORT FOR EVENT " << iEvent.id().event() << " RUN " << iEvent.run() << " LUMI " << iEvent.luminosityBlock() << " === " << std::endl;
         print(*errors);
     }
 
 
     if (fail) { nfailLumi_++; nfailRun_++; } else { npassRun_++; npassLumi_++; }
     iEvent.put( std::auto_ptr<bool>(new bool(fail)) );  // fail is the unbiased boolean 
 
     if(taggedMode_) return forcedValue_;
     return save;
 }

template<typename Collection >

void LogErrorEventFilter::increment	(	ErrorSet &	scoreboard,
		Collection &	list
	)

staticprivate

Definition at line 273 of file LogErrorEventFilter.cc.

References edm::ErrorSummaryEntry::count, and query::result.

Referenced by beginLuminosityBlock(), endLuminosityBlock(), and endRun().

                                                                      {
     foreach (const Error &err, list) {
         std::pair<ErrorSet::iterator, bool> result = scoreboard.insert(err);
         // need the const_cast as set elements are const
          if (!result.second) const_cast<unsigned int &>(result.first->count) += err.count;
     }
 }

template<typename Collection >

void LogErrorEventFilter::print ( const Collection & errors )

staticprivate

Definition at line 283 of file LogErrorEventFilter.cc.

References edm::ErrorSummaryEntry::category, edm::ErrorSummaryEntry::count, gather_cfg::cout, edm::ELseverityLevel::getName(), edm::ErrorSummaryEntry::module, and edm::ErrorSummaryEntry::severity.

Referenced by endJob(), endLuminosityBlock(), endRun(), and filter().

                                                    {
     using namespace std;
     cout << setw(40) << left  << "Category" << " " <<
             setw(60) << left  << "Module"   << " " <<
             setw(10) << left  << "Level"    << " " <<
             setw(9)  << right << "Count"    << "\n";
     cout << setw(40) << left  << "----------------------------------------"                       << " " <<
             setw(60) << left  << "------------------------------------------------------------"   << " " <<
             setw(10) << left  << "----------"                                                     << " " <<
             setw(9)  << right << "---------"                                                      << "\n";
     foreach (const Error &err, errors) {
         cout << setw(40) << left  << err.category           << " " <<
                 setw(60) << left  << err.module             << " " <<
                 setw(10) << left  << err.severity.getName() << " " <<
                 setw(9)  << right << err.count << "\n";
     }
     cout << flush;
 }

static std::auto_ptr<ErrorList > LogErrorEventFilter::serialize ( const ErrorSet & set )

inlinestaticprivate

Definition at line 82 of file LogErrorEventFilter.cc.

References run_regression::ret.

Referenced by endLuminosityBlockProduce().

                                                                       {
             std::auto_ptr<ErrorList> ret(new ErrorList(set.begin(), set.end()));
             return ret;
         }