Inheritance diagram for LogErrorEventFilter:

Classes
struct	ErrorSort

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

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

virtual void	endJob ()

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

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

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

	LogErrorEventFilter (const edm::ParameterSet &iConfig)

virtual	~LogErrorEventFilter ()

Public Member Functions inherited from edm::EDFilter
	EDFilter ()

virtual	~EDFilter ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

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_

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::EDFilter
typedef EDFilter	ModuleType

typedef WorkerT< EDFilter >	WorkerType

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Protected Member Functions inherited from edm::EDFilter
CurrentProcessingContext const *	currentContext () const

Protected Member Functions inherited from edm::ProducerBase
template<class TProducer , class TMethod >
void	callWhenNewProductsRegistered (TProducer *iProd, TMethod iMethod)

Detailed Description

Definition at line 33 of file LogErrorEventFilter.cc.

Member Typedef Documentation

typedef edm::ErrorSummaryEntry LogErrorEventFilter::Error

private

Definition at line 46 of file LogErrorEventFilter.cc.

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

private

Definition at line 55 of file LogErrorEventFilter.cc.

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

private

Definition at line 56 of file LogErrorEventFilter.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 84 of file LogErrorEventFilter.cc.

References ecalBxOrbitNumberGrapher_cfg::categories, categoriesToIgnore_, categoriesToWatch_, filterCSVwithJSON::copy, gather_cfg::cout, hcal_timing_source_file_cfg::dump, edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), modulesToIgnore_, and modulesToWatch_.

                                                                         :
     src_(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 36 of file LogErrorEventFilter.cc.

36 { }

Member Function Documentation

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

virtual

Reimplemented from edm::EDFilter.

Definition at line 135 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_;
     }
     return true;
 }

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

virtual

Reimplemented from edm::EDFilter.

Definition at line 173 of file LogErrorEventFilter.cc.

References errorCollectionThisRun_, nfailRun_, and npassRun_.

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

void LogErrorEventFilter::endJob ( void )

virtual

Reimplemented from edm::EDFilter.

Definition at line 196 of file LogErrorEventFilter.cc.

References 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 %7lu, pass %7lu, 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 %7lu, pass %7lu, 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)" : ""));
         }
     }
 }

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

virtual

Reimplemented from edm::EDFilter.

Definition at line 154 of file LogErrorEventFilter.cc.

References gather_cfg::cout, errorCollectionThisLumi_, errorCollectionThisRun_, increment(), edm::LuminosityBlockBase::luminosityBlock(), nfailLumi_, npassLumi_, print(), edm::LuminosityBlock::put(), edm::LuminosityBlockBase::run(), serialize(), 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_);
         }
     }
     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");
     return true;
 }

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

virtual

Reimplemented from edm::EDFilter.

Definition at line 180 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_));
     return true;
 }

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

virtual

Implements edm::EDFilter.

Definition at line 220 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::getByLabel(), edm::EventBase::id(), if(), edm::EventBase::luminosityBlock(), maxSavedEventsPerLumi_, edm::ErrorSummaryEntry::module, modulesToIgnore_, modulesToWatch_, nfailLumi_, nfailRun_, npassLumi_, npassRun_, print(), edm::Event::put(), readSummaryMode_, query::result, edm::Event::run(), src_, 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.getByLabel(src_, 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 269 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 279 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 78 of file LogErrorEventFilter.cc.

References run_regression::ret.

Referenced by endLuminosityBlock().

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