GPetrucc/plugins/LogErrorAnalysis.cc

//
// $Id: LogErrorAnalysis.cc,v 1.1 2009/05/28 17:33:26 gpetrucc Exp $
//

/**
  \class    gLogErrorAnalysis PATMuonKinematics.h "PhysicsTools/PatAlgos/interface/PATMuonKinematics.h"
  \brief    Use StandAlone track to define the 4-momentum of a PAT Muon (normally the global one is used)
            
  \author   Giovanni Petrucciani
  \version  $Id: LogErrorAnalysis.cc,v 1.1 2009/05/28 17:33:26 gpetrucc Exp $
*/


#include "FWCore/Framework/interface/EDFilter.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/Run.h"
#include "FWCore/Framework/interface/LuminosityBlock.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/InputTag.h"

#include "FWCore/MessageLogger/interface/ErrorSummaryEntry.h"

#include <map>
#include <set>
#include <string>
#include <iomanip>
#include <iterator>
#include <boost/foreach.hpp>
#define foreach BOOST_FOREACH


class LogErrorAnalysis : public edm::EDFilter {
    public:
        explicit LogErrorAnalysis(const edm::ParameterSet & iConfig);
        virtual ~LogErrorAnalysis() { }

        virtual bool filter(edm::Event & iEvent, const edm::EventSetup & iSetup);
        virtual bool beginLuminosityBlock(edm::LuminosityBlock &lumi, const edm::EventSetup &iSetup);
        virtual bool endLuminosityBlock(edm::LuminosityBlock &lumi, const edm::EventSetup &iSetup);
        virtual bool beginRun(edm::Run &run, const edm::EventSetup &iSetup);
        virtual bool endRun(edm::Run &run, const edm::EventSetup &iSetup);
        virtual void endJob();

    private:
        typedef edm::ErrorSummaryEntry              Error;
        struct ErrorSort {
            bool operator()(const Error &e1, const Error &e2) {
                if (e1.severity.getLevel() != e2.severity.getLevel()) return e1.severity.getLevel() > e2.severity.getLevel();
                if (e1.module != e2.module) return e1.module < e2.module;
                if (e1.category != e2.category) return e1.category < e2.category;
                return false;
            }
        };
        typedef std::vector<edm::ErrorSummaryEntry> ErrorList;
        typedef std::set<edm::ErrorSummaryEntry,ErrorSort>    ErrorSet;

        edm::InputTag src_;
        bool readSummaryMode_;
        size_t npassLumi_, nfailLumi_;
        size_t npassRun_, nfailRun_;
        std::set<std::string> modulesToWatch_;
        std::set<std::string> modulesToIgnore_;
        std::set<std::string> categoriesToWatch_;
        std::set<std::string> categoriesToIgnore_;
        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_;
        ErrorSet errorCollectionAll_;
        ErrorSet errorCollectionThisLumi_, errorCollectionThisRun_;
        double thresholdPerLumi_, thresholdPerRun_;
        size_t maxSavedEventsPerLumi_;
        bool verbose_, veryVerbose_;

        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) {
            std::auto_ptr<ErrorList> ret(new ErrorList(set.begin(), set.end()));
            return ret;
        }
};

LogErrorAnalysis::LogErrorAnalysis(const edm::ParameterSet & iConfig) :
    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))
{
    produces<ErrorList, edm::InLumi>();
    produces<int, edm::InLumi>("pass");
    produces<int, edm::InLumi>("fail");
    //produces<ErrorList, edm::InRun>();

    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;

}

bool
LogErrorAnalysis::beginLuminosityBlock(edm::LuminosityBlock &lumi, const edm::EventSetup &iSetup) {
    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
LogErrorAnalysis::endLuminosityBlock(edm::LuminosityBlock &lumi, const edm::EventSetup &iSetup) {
    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
LogErrorAnalysis::beginRun(edm::Run &run, const edm::EventSetup &iSetup) {
    npassRun_ = 0; nfailRun_ = 0;
    errorCollectionThisRun_.clear();
    return true;
}

bool
LogErrorAnalysis::endRun(edm::Run &run, const edm::EventSetup &iSetup) {
    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;
}

void
LogErrorAnalysis::endJob() {
    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 %7d, pass %7d, 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 %7d, pass %7d, 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 
LogErrorAnalysis::filter(edm::Event & iEvent, const edm::EventSetup & iSetup) {
    if (readSummaryMode_) return true;

    bool fail = false, save = false;

    edm::Handle<ErrorList> errors;
    iEvent.getByLabel(src_, errors);

   
    if (errors->empty()) { 
        npassRun_++; npassLumi_++;
        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_++; }
    return save;
}

template<typename Collection> 
void
LogErrorAnalysis::increment(ErrorSet &scoreboard, Collection &list) {
    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
LogErrorAnalysis::print(const Collection &errors) {
    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;
}

#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(LogErrorAnalysis);
Revision:	1.1
Committed:	Tue Jan 26 09:47:36 2010 UTC (15 years, 3 months ago) by gpetrucc
Content type:	text/plain
Branch:	MAIN
CVS Tags:	V03-00-00, V02-00-00
Log Message:	Skim events with errors
#	User	Rev	Content
1	gpetrucc	1.1	//
2			// $Id: LogErrorAnalysis.cc,v 1.1 2009/05/28 17:33:26 gpetrucc Exp $
3			//
4
5			/**
6			\class gLogErrorAnalysis PATMuonKinematics.h "PhysicsTools/PatAlgos/interface/PATMuonKinematics.h"
7			\brief Use StandAlone track to define the 4-momentum of a PAT Muon (normally the global one is used)
8
9			\author Giovanni Petrucciani
10			\version $Id: LogErrorAnalysis.cc,v 1.1 2009/05/28 17:33:26 gpetrucc Exp $
11			*/
12
13
14			#include "FWCore/Framework/interface/EDFilter.h"
15			#include "FWCore/Framework/interface/Event.h"
16			#include "FWCore/Framework/interface/Run.h"
17			#include "FWCore/Framework/interface/LuminosityBlock.h"
18			#include "FWCore/ParameterSet/interface/ParameterSet.h"
19			#include "FWCore/ParameterSet/interface/InputTag.h"
20
21			#include "FWCore/MessageLogger/interface/ErrorSummaryEntry.h"
22
23			#include <map>
24			#include <set>
25			#include <string>
26			#include <iomanip>
27			#include <iterator>
28			#include <boost/foreach.hpp>
29			#define foreach BOOST_FOREACH
30
31
32			class LogErrorAnalysis : public edm::EDFilter {
33			public:
34			explicit LogErrorAnalysis(const edm::ParameterSet & iConfig);
35			virtual ~LogErrorAnalysis() { }
36
37			virtual bool filter(edm::Event & iEvent, const edm::EventSetup & iSetup);
38			virtual bool beginLuminosityBlock(edm::LuminosityBlock &lumi, const edm::EventSetup &iSetup);
39			virtual bool endLuminosityBlock(edm::LuminosityBlock &lumi, const edm::EventSetup &iSetup);
40			virtual bool beginRun(edm::Run &run, const edm::EventSetup &iSetup);
41			virtual bool endRun(edm::Run &run, const edm::EventSetup &iSetup);
42			virtual void endJob();
43
44			private:
45			typedef edm::ErrorSummaryEntry Error;
46			struct ErrorSort {
47			bool operator()(const Error &e1, const Error &e2) {
48			if (e1.severity.getLevel() != e2.severity.getLevel()) return e1.severity.getLevel() > e2.severity.getLevel();
49			if (e1.module != e2.module) return e1.module < e2.module;
50			if (e1.category != e2.category) return e1.category < e2.category;
51			return false;
52			}
53			};
54			typedef std::vector<edm::ErrorSummaryEntry> ErrorList;
55			typedef std::set<edm::ErrorSummaryEntry,ErrorSort> ErrorSet;
56
57			edm::InputTag src_;
58			bool readSummaryMode_;
59			size_t npassLumi_, nfailLumi_;
60			size_t npassRun_, nfailRun_;
61			std::set<std::string> modulesToWatch_;
62			std::set<std::string> modulesToIgnore_;
63			std::set<std::string> categoriesToWatch_;
64			std::set<std::string> categoriesToIgnore_;
65			std::map<std::pair<uint32_t,uint32_t>, std::pair<size_t,size_t> > statsPerLumi_;
66			std::map<uint32_t, std::pair<size_t,size_t> > statsPerRun_;
67			ErrorSet errorCollectionAll_;
68			ErrorSet errorCollectionThisLumi_, errorCollectionThisRun_;
69			double thresholdPerLumi_, thresholdPerRun_;
70			size_t maxSavedEventsPerLumi_;
71			bool verbose_, veryVerbose_;
72
73			template<typename Collection> static void increment(ErrorSet &scoreboard, Collection &list);
74			template<typename Collection> static void print(const Collection &errors) ;
75
76			static std::auto_ptr<ErrorList > serialize(const ErrorSet &set) {
77			std::auto_ptr<ErrorList> ret(new ErrorList(set.begin(), set.end()));
78			return ret;
79			}
80			};
81
82			LogErrorAnalysis::LogErrorAnalysis(const edm::ParameterSet & iConfig) :
83			src_(iConfig.getParameter<edm::InputTag>("src")),
84			readSummaryMode_(iConfig.existsAs<bool>("readSummaryMode") ? iConfig.getParameter<bool>("readSummaryMode") : false),
85			thresholdPerLumi_(iConfig.getParameter<double>("maxErrorFractionInLumi")),
86			thresholdPerRun_(iConfig.getParameter<double>("maxErrorFractionInRun")),
87			maxSavedEventsPerLumi_(iConfig.getParameter<uint32_t>("maxSavedEventsPerLumiAndError")),
88			verbose_(iConfig.getUntrackedParameter<bool>("verbose", false)),
89			veryVerbose_(iConfig.getUntrackedParameter<bool>("veryVerbose", false))
90			{
91			produces<ErrorList, edm::InLumi>();
92			produces<int, edm::InLumi>("pass");
93			produces<int, edm::InLumi>("fail");
94			//produces<ErrorList, edm::InRun>();
95
96			if (iConfig.existsAs<std::vector<std::string> >("modulesToWatch")) {
97			std::vector<std::string> modules = iConfig.getParameter<std::vector<std::string> >("modulesToWatch");
98			if (!(modules.size() == 1 && modules[0] == "*")) {
99			modulesToWatch_.insert(modules.begin(), modules.end());
100			}
101			}
102			if (iConfig.existsAs<std::vector<std::string> >("modulesToIgnore")) {
103			std::vector<std::string> modules = iConfig.getParameter<std::vector<std::string> >("modulesToIgnore");
104			if (!(modules.size() == 1 && modules[0] == "*")) {
105			modulesToIgnore_.insert(modules.begin(), modules.end());
106			}
107			}
108			if (iConfig.existsAs<std::vector<std::string> >("categoriesToWatch")) {
109			std::vector<std::string> categories = iConfig.getParameter<std::vector<std::string> >("categoriesToWatch");
110			if (!(categories.size() == 1 && categories[0] == "*")) {
111			categoriesToWatch_.insert(categories.begin(), categories.end());
112			}
113			}
114			if (iConfig.existsAs<std::vector<std::string> >("categoriesToIgnore")) {
115			std::vector<std::string> categories = iConfig.getParameter<std::vector<std::string> >("categoriesToIgnore");
116			if (!(categories.size() == 1 && categories[0] == "*")) {
117			categoriesToIgnore_.insert(categories.begin(), categories.end());
118			}
119			}
120			std::ostream_iterator<std::string> dump(std::cout, ", ");
121			std::cout << "\nWatch modules: " ; std::copy(modulesToWatch_.begin(), modulesToWatch_.end(), dump);
122			std::cout << "\nIgnore modules: " ; std::copy(modulesToIgnore_.begin(), modulesToIgnore_.end(), dump);
123			std::cout << "\nIgnore categories: " ; std::copy(categoriesToIgnore_.begin(), categoriesToIgnore_.end(), dump);
124			std::cout << "\nWatch categories: " ; std::copy(categoriesToWatch_.begin(), categoriesToWatch_.end(), dump);
125			std::cout << std::endl;
126
127			}
128
129			bool
130			LogErrorAnalysis::beginLuminosityBlock(edm::LuminosityBlock &lumi, const edm::EventSetup &iSetup) {
131			npassLumi_ = 0; nfailLumi_ = 0;
132			errorCollectionThisLumi_.clear();
133			if (readSummaryMode_) {
134			edm::Handle<ErrorList> handle;
135			edm::Handle<int> hpass, hfail;
136			lumi.getByLabel(src_, handle);
137			lumi.getByLabel(edm::InputTag(src_.label(), "pass", src_.process()), hpass);
138			lumi.getByLabel(edm::InputTag(src_.label(), "fail", src_.process()), hfail);
139			increment(errorCollectionThisLumi_, *handle);
140			npassLumi_ = *hpass;
141			nfailLumi_ = *hfail;
142			npassRun_ += npassLumi_;
143			nfailRun_ += nfailLumi_;
144			}
145			return true;
146			}
147
148			bool
149			LogErrorAnalysis::endLuminosityBlock(edm::LuminosityBlock &lumi, const edm::EventSetup &iSetup) {
150			statsPerLumi_[std::pair<uint32_t,uint32_t>(lumi.run(), lumi.luminosityBlock())] = std::pair<size_t,size_t>(npassLumi_, nfailLumi_);
151			if (nfailLumi_ < thresholdPerLumi_*(npassLumi_+nfailLumi_)) {
152			increment(errorCollectionThisRun_, errorCollectionThisLumi_);
153			}
154			if (verbose_) {
155			if (!errorCollectionThisLumi_.empty()) {
156			std::cout << "\n === REPORT FOR RUN " << lumi.run() << " LUMI " << lumi.luminosityBlock() << " === " << std::endl;
157			print(errorCollectionThisLumi_);
158			}
159			}
160			lumi.put(serialize(errorCollectionThisLumi_));
161			std::auto_ptr<int> outpass(new int(npassLumi_)); lumi.put(outpass, "pass");
162			std::auto_ptr<int> outfail(new int(nfailLumi_)); lumi.put(outfail, "fail");
163			return true;
164			}
165
166
167			bool
168			LogErrorAnalysis::beginRun(edm::Run &run, const edm::EventSetup &iSetup) {
169			npassRun_ = 0; nfailRun_ = 0;
170			errorCollectionThisRun_.clear();
171			return true;
172			}
173
174			bool
175			LogErrorAnalysis::endRun(edm::Run &run, const edm::EventSetup &iSetup) {
176			statsPerRun_[run.run()] = std::pair<size_t,size_t>(npassRun_, nfailRun_);
177			if (nfailRun_ < thresholdPerRun_*(npassRun_+nfailRun_)) {
178			increment(errorCollectionAll_, errorCollectionThisRun_);
179			}
180			if (verbose_) {
181			if (!errorCollectionThisRun_.empty()) {
182			std::cout << "\n === REPORT FOR RUN " << run.run() << " === " << std::endl;
183			print(errorCollectionThisRun_);
184			}
185			}
186			//run.put(serialize(errorCollectionThisRun_));
187			return true;
188			}
189
190			void
191			LogErrorAnalysis::endJob() {
192			if (verbose_) {
193			std::cout << "\n === REPORT FOR JOB === " << std::endl;
194			print(errorCollectionAll_);
195
196			typedef std::pair<size_t,size_t> counter;
197
198			std::cout << "\n === SCOREBOARD PER RUN === " << std::endl;
199			typedef std::pair<uint32_t, counter> hitRun;
200			foreach(const hitRun &hit, statsPerRun_) {
201			double fract = hit.second.second/double(hit.second.first + hit.second.second);
202			printf("run %6d: fail %7d, pass %7d, fraction %7.3f%%%s\n", hit.first, hit.second.second, hit.second.first, fract*100., (fract >= thresholdPerRun_ ? " (run excluded from summary list)" : ""));
203			}
204
205			std::cout << "\n === SCOREBOARD PER LUMI === " << std::endl;
206			typedef std::pair<std::pair<uint32_t,uint32_t>, counter> hitLumi;
207			foreach(const hitLumi &hit, statsPerLumi_) {
208			double fract = hit.second.second/double(hit.second.first + hit.second.second);
209			printf("run %6d, lumi %4d: fail %7d, pass %7d, 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)" : ""));
210			}
211			}
212			}
213
214			bool
215			LogErrorAnalysis::filter(edm::Event & iEvent, const edm::EventSetup & iSetup) {
216			if (readSummaryMode_) return true;
217
218			bool fail = false, save = false;
219
220			edm::Handle<ErrorList> errors;
221			iEvent.getByLabel(src_, errors);
222
223
224			if (errors->empty()) {
225			npassRun_++; npassLumi_++;
226			return false;
227			}
228
229			foreach (const Error &err, *errors) {
230			if (!modulesToWatch_.empty() && (modulesToWatch_.count(err.module) == 0)) continue;
231			if (!categoriesToWatch_.empty() && (categoriesToWatch_.count(err.category) == 0)) continue;
232			if (!modulesToIgnore_.empty() && (modulesToIgnore_.count(err.module) != 0)) continue;
233			if (!categoriesToIgnore_.empty() && (categoriesToIgnore_.count(err.category) != 0)) continue;
234
235			fail = true;
236			std::pair<ErrorSet::iterator, bool> result = errorCollectionThisLumi_.insert(err);
237			if (!result.second) { // already there
238			// need the const_cast as set elements are const
239			const_cast<unsigned int &>(result.first->count) += err.count;
240			if (result.first->count < maxSavedEventsPerLumi_) save = true;
241			} else {
242			save = true;
243			}
244
245			}
246			if (save && veryVerbose_) {
247			std::cout << "\n === REPORT FOR EVENT " << iEvent.id().event() << " RUN " << iEvent.run() << " LUMI " << iEvent.luminosityBlock() << " === " << std::endl;
248			print(*errors);
249			}
250
251
252			if (fail) { nfailLumi_++; nfailRun_++; } else { npassRun_++; npassLumi_++; }
253			return save;
254			}
255
256			template<typename Collection>
257			void
258			LogErrorAnalysis::increment(ErrorSet &scoreboard, Collection &list) {
259			foreach (const Error &err, list) {
260			std::pair<ErrorSet::iterator, bool> result = scoreboard.insert(err);
261			// need the const_cast as set elements are const
262			if (!result.second) const_cast<unsigned int &>(result.first->count) += err.count;
263			}
264			}
265
266			template<typename Collection>
267			void
268			LogErrorAnalysis::print(const Collection &errors) {
269			using namespace std;
270			cout << setw(40) << left << "Category" << " " <<
271			setw(60) << left << "Module" << " " <<
272			setw(10) << left << "Level" << " " <<
273			setw(9) << right << "Count" << "\n";
274			cout << setw(40) << left << "----------------------------------------" << " " <<
275			setw(60) << left << "------------------------------------------------------------" << " " <<
276			setw(10) << left << "----------" << " " <<
277			setw(9) << right << "---------" << "\n";
278			foreach (const Error &err, errors) {
279			cout << setw(40) << left << err.category << " " <<
280			setw(60) << left << err.module << " " <<
281			setw(10) << left << err.severity.getName() << " " <<
282			setw(9) << right << err.count << "\n";
283			}
284			cout << flush;
285			}
286
287			#include "FWCore/Framework/interface/MakerMacros.h"
288			DEFINE_FWK_MODULE(LogErrorAnalysis);