Tools/src/Event.cpp

/*
 * Event.cpp
 *
 *  Created on: Jun 25, 2010
 *      Author: lkreczko
 */

#include "../interface/Event.h"
#include <iostream>
using namespace std;

namespace BAT {
bool Event::useCustomConversionTagger = false;
bool Event::usePFIsolation = false;
Event::Event() :
    HLTs(new std::vector<int>()),
    vertices(),
    goodVertices(),
    tracks(),
    allElectrons(),
    goodElectrons(),
    goodIsolatedElectrons(),
    goodPFIsolatedElectrons(),
    looseElectrons(),
    qcdElectrons(),
    allJets(),
    goodJets(),
    goodBJets(),
    allMuons(),
    goodMuons(),
    goodIsolatedMuons(),
    looseMuons(),
    genParticles(),
    met(),
    dataType(DataType::DATA),
    runNumber(0),
    eventNumber(0),
    lumiBlock(0),
    eventWeight(1.),
    jetCleaningEfficiency(1.),
    numberOfHighPurityTracks(0),
    isBeamScraping(true),
    genNumberOfPileUpVertices(0){
}

Event::~Event() {
}

bool Event::isRealData() const {
    return dataType == DataType::DATA;
}

const DataType::value Event::getDataType() const {
    return dataType;
}

void Event::setDataType(DataType::value type) {
    dataType = type;
}

void Event::setVertices(VertexCollection vertices) {
    this->vertices.clear();
    this->vertices = vertices;

        selectVerticesByQuality();
}

void Event::selectVerticesByQuality() {
    goodVertices.clear();

    for (unsigned int i = 0; i < vertices.size(); ++i) {
        if (vertices.at(i)->isGood())
            goodVertices.push_back(vertices.at(i));
    }
}

void Event::setTracks(TrackCollection tracks) {
    this->tracks.clear();
    this->tracks = tracks;
    numberOfHighPurityTracks = 0;
    for (unsigned int index = 0; index < tracks.size(); ++index) {
        if (tracks.at(index)->isHighPurity())
            numberOfHighPurityTracks++;
    }
}

void Event::setGenParticles(MCParticleCollection genParticles) {
        this->genParticles = genParticles;
}

void Event::setElectrons(ElectronCollection electrons) {
    allElectrons.clear();
    allElectrons = electrons;
    selectElectronsByQuality();
}


void Event::setLoosePFElectrons(ElectronCollection electrons) {
    loosePFElectrons.clear();
    loosePFElectrons = electrons;
}


void Event::selectElectronsByQuality() {
    goodElectrons.clear();
    goodIsolatedElectrons.clear();
    goodPFIsolatedElectrons.clear();
    for (unsigned int index = 0; index < allElectrons.size(); ++index) {
        ElectronPointer electron = allElectrons.at(index);

        if (electron->isGood())
            goodElectrons.push_back(electron);

        if(electron->isGood(20))
            qcdElectrons.push_back(electron);

        if (electron->isGood() && electron->isIsolated())
            goodIsolatedElectrons.push_back(electron);

        if(electron->algorithm() == ElectronAlgorithm::ParticleFlow){
            if(electron->isGood() && electron->isPFIsolated())
                goodPFIsolatedElectrons.push_back(electron);
        }
        if (electron->isLoose())
            looseElectrons.push_back(electron);
    }
}

void Event::setJets(JetCollection jets) {
    allJets.clear();
    allJets = jets;
    selectGoodJets();
}

void Event::setGenJets(JetCollection jets) {
    genJets.clear();
    genJets = jets;
}


void Event::selectGoodJets() {
    goodJets.clear();
    for (unsigned int index = 0; index < allJets.size(); ++index) {
        const JetPointer jet = allJets.at(index);
        if (jet->isGood()) {
            goodJets.push_back(jet);
        }
    }
    cleanGoodJets();
    for (unsigned int index = 0; index < goodJets.size(); ++index) {
        const JetPointer jet = goodJets.at(index);
        if (jet->isBJet(BtagAlgorithm::SimpleSecondaryVertexHighEffBTag))
            goodBJets.push_back(jet);
    }
}

void Event::cleanGoodJets() {
    if (goodJets.size() > 0) {
                        if (goodPFIsolatedElectrons.size() > 0)
                                        cleanGoodJetsAgainstIsolatedLeptons(goodPFIsolatedElectrons);
                        if (goodIsolatedMuons.size() > 0)
                                cleanGoodJetsAgainstIsolatedLeptons(goodIsolatedMuons);
                }
}

template <class PartColl> void Event::cleanGoodJetsAgainstIsolatedLeptons(const PartColl &leptonColl) {
    unsigned int initialGoodJets = goodJets.size();
    for (unsigned int jetIndex = 0; jetIndex < goodJets.size(); ++jetIndex) {
        for (unsigned int leptonIndex = 0; leptonIndex < leptonColl.size(); ++leptonIndex) {
            if (goodJets.at(jetIndex)->isWithinDeltaR(0.3, leptonColl.at(leptonIndex))) {
                goodJets.erase(goodJets.begin() + jetIndex);
                --jetIndex;
                break;
            }
        }
    }
    jetCleaningEfficiency = goodJets.size() / initialGoodJets;
}

void Event::cleanGoodJetsAgainstMostIsolatedElectron() {
    const ElectronPointer mostIsolatedElectron = MostIsolatedElectron(Event::usePFIsolation);
    unsigned int initialGoodJets = goodJets.size();
    for (unsigned int jetIndex = 0; jetIndex < goodJets.size(); ++jetIndex) {
        if (goodJets.at(jetIndex)->isWithinDeltaR(0.3, mostIsolatedElectron)) {
            goodJets.erase(goodJets.begin() + jetIndex);
            --jetIndex;
        }
    }
    jetCleaningEfficiency = goodJets.size() / initialGoodJets;
}

const ElectronPointer Event::MostIsolatedElectron(bool usePFIso) const {
    float bestIsolation = 999999999;
    unsigned int bestIsolatedElectron = 990;
    for (unsigned int index = 0; index < allElectrons.size(); ++index) {
        float currentIsolation = 999999999;
        if(usePFIso)
            currentIsolation = allElectrons.at(index)->pfIsolation();
        else
            currentIsolation = allElectrons.at(index)->relativeIsolation();

        if (currentIsolation < bestIsolation) {
            bestIsolation = currentIsolation;
            bestIsolatedElectron = index;
        }
    }
    return allElectrons.at(bestIsolatedElectron);
}

const ElectronPointer Event::MostIsolatedElectron() const{
    return MostIsolatedElectron(false);
}

const ElectronPointer Event::MostPFIsolatedElectron() const{
    return MostIsolatedElectron(true);
}


void Event::setMuons(MuonCollection muons) {
    allMuons.clear();
    allMuons = muons;
    selectMuonsByQuality();
}

void Event::selectMuonsByQuality() {
    goodMuons.clear();
    goodIsolatedMuons.clear();
    for (unsigned int index = 0; index < allMuons.size(); ++index) {
        MuonPointer muon = allMuons.at(index);

        if (muon->isGood())
            goodMuons.push_back(muon);

        if (muon->isGood() && muon->isIsolated())
            goodIsolatedMuons.push_back(muon);
        if (muon->isLoose())
            looseMuons.push_back(muon);
    }
}

void Event::setHLTs(const boost::shared_ptr<std::vector<int> > triggers){
    HLTs = triggers;
}

void Event::setMET(const METPointer met) {
    this->met = met;
    this->met->adjForUnc(allJets);
}

void Event::setRunNumber(unsigned long number) {
    runNumber = number;
}

void Event::setEventNumber(unsigned long number) {
    eventNumber = number;
}

void Event::setLocalEventNumber(unsigned long number) {
    localEventNumber = number;
}

void Event::setLumiBlock(unsigned long block) {
    lumiBlock = block;
}

void Event::setEventWeight(float weight) {
    eventWeight = weight;
}

void Event::setBeamScrapingVeto(bool isScraping){
    isBeamScraping = isScraping;
}

const VertexPointer Event::PrimaryVertex() const {
    return goodVertices.front();
}

const VertexCollection& Event::Vertices() const {
    return vertices;
}

const VertexCollection& Event::GoodVertices() const {
    return goodVertices;
}

const TrackCollection& Event::Tracks() const {
    return tracks;
}

const ElectronCollection& Event::Electrons() const {
    return allElectrons;
}

const ElectronCollection& Event::GoodElectrons() const {
    return goodElectrons;
}

const ElectronCollection& Event::GoodIsolatedElectrons() const {
    return goodIsolatedElectrons;
}

const ElectronCollection& Event::GoodPFIsolatedElectrons() const {
    return goodPFIsolatedElectrons;
}

const ElectronCollection& Event::QCDElectrons() const{
    return qcdElectrons;
}

const ElectronCollection& Event::LoosePFElectrons() const{
    return loosePFElectrons;
}

const JetCollection& Event::Jets() const {
    return allJets;
}

const JetCollection& Event::GenJets() const {
    return genJets;
}


const JetCollection& Event::GoodJets() const {
    return goodJets;
}

const JetCollection& Event::GoodBJets() const {
    return goodBJets;
}

const MuonCollection& Event::Muons() const {
    return allMuons;
}

const MuonCollection& Event::GoodMuons() const {
    return goodMuons;
}

const MuonCollection& Event::GoodIsolatedMuons() const {
    return goodIsolatedMuons;
}

const MCParticleCollection& Event::GenParticles() const {
        return genParticles;
}

const METPointer Event::MET() const {
    return met;
}

unsigned long Event::runnumber() const {
    return runNumber;
}

unsigned long Event::eventnumber() const {
    return eventNumber;
}

unsigned long Event::localnumber() const {
    return localEventNumber;
}

unsigned long Event::lumiblock() const {
    return lumiBlock;
}

float Event::weight() const {
    return eventWeight;
}

void Event::inspect() const {
    cout << "run " << runNumber << ", event number " << eventNumber << ", lumi section " << lumiBlock << endl;

    cout << "number of tracks: " << tracks.size() << endl;
    cout << "number of high purity tracks: " << numberOfHighPurityTracks << endl;

    cout << "number of jets: " << allJets.size() << endl;
    EventContentPrinter::printJets(allJets);
    cout << "number of good jets: " << goodJets.size() << endl;
    EventContentPrinter::printJets(goodJets);

    cout << "number of good isolated electrons: " << goodIsolatedElectrons.size() << endl;
    EventContentPrinter::printElectrons(goodIsolatedElectrons);

    cout << "number of good electrons: " << goodElectrons.size() << endl;
    EventContentPrinter::printElectrons(goodElectrons);

    cout << "number of electrons: " << allElectrons.size() << endl;
    EventContentPrinter::printElectrons(allElectrons);
}

bool Event::HLT(HLTriggers::value trigger) const{
                if (trigger >= (int) HLTs->size()) {
                                static bool showMsg = true;
                                if (showMsg) {
                                        cout << "Seeking trigger # " << trigger << " but only ";
                                        cout << HLTs->size() << " triggers in ntuple\n";
                                        showMsg = false;
                                }
                                return false;
                }
    return (HLTs->at(trigger) > 0);
}

void Event::setGenNumberOfPileUpVertices(unsigned int pileup){
    genNumberOfPileUpVertices = pileup;
}

float Event::numberOfGeneratedPileUpVertices() const{
    return genNumberOfPileUpVertices;
}

}
Revision:	1.1.1.1 (vendor branch)
Committed:	Thu Dec 1 16:28:48 2011 UTC (13 years, 5 months ago) by dhidas
Branch:	dhidas, MAIN
CVS Tags:	START, HEAD
Changes since 1.1:	+0 -0 lines
Error occurred while calculating annotation data.
Log Message:	osu copy modified
#	Content
1	/*
2	* Event.cpp
3	*
4	* Created on: Jun 25, 2010
5	* Author: lkreczko
6	*/
7
8	#include "../interface/Event.h"
9	#include <iostream>
10	using namespace std;
11
12	namespace BAT {
13	bool Event::useCustomConversionTagger = false;
14	bool Event::usePFIsolation = false;
15	Event::Event() :
16	HLTs(new std::vector<int>()),
17	vertices(),
18	goodVertices(),
19	tracks(),
20	allElectrons(),
21	goodElectrons(),
22	goodIsolatedElectrons(),
23	goodPFIsolatedElectrons(),
24	looseElectrons(),
25	qcdElectrons(),
26	allJets(),
27	goodJets(),
28	goodBJets(),
29	allMuons(),
30	goodMuons(),
31	goodIsolatedMuons(),
32	looseMuons(),
33	genParticles(),
34	met(),
35	dataType(DataType::DATA),
36	runNumber(0),
37	eventNumber(0),
38	lumiBlock(0),
39	eventWeight(1.),
40	jetCleaningEfficiency(1.),
41	numberOfHighPurityTracks(0),
42	isBeamScraping(true),
43	genNumberOfPileUpVertices(0){
44	}
45
46	Event::~Event() {
47	}
48
49	bool Event::isRealData() const {
50	return dataType == DataType::DATA;
51	}
52
53	const DataType::value Event::getDataType() const {
54	return dataType;
55	}
56
57	void Event::setDataType(DataType::value type) {
58	dataType = type;
59	}
60
61	void Event::setVertices(VertexCollection vertices) {
62	this->vertices.clear();
63	this->vertices = vertices;
64
65	selectVerticesByQuality();
66	}
67
68	void Event::selectVerticesByQuality() {
69	goodVertices.clear();
70
71	for (unsigned int i = 0; i < vertices.size(); ++i) {
72	if (vertices.at(i)->isGood())
73	goodVertices.push_back(vertices.at(i));
74	}
75	}
76
77	void Event::setTracks(TrackCollection tracks) {
78	this->tracks.clear();
79	this->tracks = tracks;
80	numberOfHighPurityTracks = 0;
81	for (unsigned int index = 0; index < tracks.size(); ++index) {
82	if (tracks.at(index)->isHighPurity())
83	numberOfHighPurityTracks++;
84	}
85	}
86
87	void Event::setGenParticles(MCParticleCollection genParticles) {
88	this->genParticles = genParticles;
89	}
90
91	void Event::setElectrons(ElectronCollection electrons) {
92	allElectrons.clear();
93	allElectrons = electrons;
94	selectElectronsByQuality();
95	}
96
97
98	void Event::setLoosePFElectrons(ElectronCollection electrons) {
99	loosePFElectrons.clear();
100	loosePFElectrons = electrons;
101	}
102
103
104	void Event::selectElectronsByQuality() {
105	goodElectrons.clear();
106	goodIsolatedElectrons.clear();
107	goodPFIsolatedElectrons.clear();
108	for (unsigned int index = 0; index < allElectrons.size(); ++index) {
109	ElectronPointer electron = allElectrons.at(index);
110
111	if (electron->isGood())
112	goodElectrons.push_back(electron);
113
114	if(electron->isGood(20))
115	qcdElectrons.push_back(electron);
116
117	if (electron->isGood() && electron->isIsolated())
118	goodIsolatedElectrons.push_back(electron);
119
120	if(electron->algorithm() == ElectronAlgorithm::ParticleFlow){
121	if(electron->isGood() && electron->isPFIsolated())
122	goodPFIsolatedElectrons.push_back(electron);
123	}
124	if (electron->isLoose())
125	looseElectrons.push_back(electron);
126	}
127	}
128
129	void Event::setJets(JetCollection jets) {
130	allJets.clear();
131	allJets = jets;
132	selectGoodJets();
133	}
134
135	void Event::setGenJets(JetCollection jets) {
136	genJets.clear();
137	genJets = jets;
138	}
139
140
141	void Event::selectGoodJets() {
142	goodJets.clear();
143	for (unsigned int index = 0; index < allJets.size(); ++index) {
144	const JetPointer jet = allJets.at(index);
145	if (jet->isGood()) {
146	goodJets.push_back(jet);
147	}
148	}
149	cleanGoodJets();
150	for (unsigned int index = 0; index < goodJets.size(); ++index) {
151	const JetPointer jet = goodJets.at(index);
152	if (jet->isBJet(BtagAlgorithm::SimpleSecondaryVertexHighEffBTag))
153	goodBJets.push_back(jet);
154	}
155	}
156
157	void Event::cleanGoodJets() {
158	if (goodJets.size() > 0) {
159	if (goodPFIsolatedElectrons.size() > 0)
160	cleanGoodJetsAgainstIsolatedLeptons(goodPFIsolatedElectrons);
161	if (goodIsolatedMuons.size() > 0)
162	cleanGoodJetsAgainstIsolatedLeptons(goodIsolatedMuons);
163	}
164	}
165
166	template <class PartColl> void Event::cleanGoodJetsAgainstIsolatedLeptons(const PartColl &leptonColl) {
167	unsigned int initialGoodJets = goodJets.size();
168	for (unsigned int jetIndex = 0; jetIndex < goodJets.size(); ++jetIndex) {
169	for (unsigned int leptonIndex = 0; leptonIndex < leptonColl.size(); ++leptonIndex) {
170	if (goodJets.at(jetIndex)->isWithinDeltaR(0.3, leptonColl.at(leptonIndex))) {
171	goodJets.erase(goodJets.begin() + jetIndex);
172	--jetIndex;
173	break;
174	}
175	}
176	}
177	jetCleaningEfficiency = goodJets.size() / initialGoodJets;
178	}
179
180	void Event::cleanGoodJetsAgainstMostIsolatedElectron() {
181	const ElectronPointer mostIsolatedElectron = MostIsolatedElectron(Event::usePFIsolation);
182	unsigned int initialGoodJets = goodJets.size();
183	for (unsigned int jetIndex = 0; jetIndex < goodJets.size(); ++jetIndex) {
184	if (goodJets.at(jetIndex)->isWithinDeltaR(0.3, mostIsolatedElectron)) {
185	goodJets.erase(goodJets.begin() + jetIndex);
186	--jetIndex;
187	}
188	}
189	jetCleaningEfficiency = goodJets.size() / initialGoodJets;
190	}
191
192	const ElectronPointer Event::MostIsolatedElectron(bool usePFIso) const {
193	float bestIsolation = 999999999;
194	unsigned int bestIsolatedElectron = 990;
195	for (unsigned int index = 0; index < allElectrons.size(); ++index) {
196	float currentIsolation = 999999999;
197	if(usePFIso)
198	currentIsolation = allElectrons.at(index)->pfIsolation();
199	else
200	currentIsolation = allElectrons.at(index)->relativeIsolation();
201
202	if (currentIsolation < bestIsolation) {
203	bestIsolation = currentIsolation;
204	bestIsolatedElectron = index;
205	}
206	}
207	return allElectrons.at(bestIsolatedElectron);
208	}
209
210	const ElectronPointer Event::MostIsolatedElectron() const{
211	return MostIsolatedElectron(false);
212	}
213
214	const ElectronPointer Event::MostPFIsolatedElectron() const{
215	return MostIsolatedElectron(true);
216	}
217
218
219	void Event::setMuons(MuonCollection muons) {
220	allMuons.clear();
221	allMuons = muons;
222	selectMuonsByQuality();
223	}
224
225	void Event::selectMuonsByQuality() {
226	goodMuons.clear();
227	goodIsolatedMuons.clear();
228	for (unsigned int index = 0; index < allMuons.size(); ++index) {
229	MuonPointer muon = allMuons.at(index);
230
231	if (muon->isGood())
232	goodMuons.push_back(muon);
233
234	if (muon->isGood() && muon->isIsolated())
235	goodIsolatedMuons.push_back(muon);
236	if (muon->isLoose())
237	looseMuons.push_back(muon);
238	}
239	}
240
241	void Event::setHLTs(const boost::shared_ptr<std::vector<int> > triggers){
242	HLTs = triggers;
243	}
244
245	void Event::setMET(const METPointer met) {
246	this->met = met;
247	this->met->adjForUnc(allJets);
248	}
249
250	void Event::setRunNumber(unsigned long number) {
251	runNumber = number;
252	}
253
254	void Event::setEventNumber(unsigned long number) {
255	eventNumber = number;
256	}
257
258	void Event::setLocalEventNumber(unsigned long number) {
259	localEventNumber = number;
260	}
261
262	void Event::setLumiBlock(unsigned long block) {
263	lumiBlock = block;
264	}
265
266	void Event::setEventWeight(float weight) {
267	eventWeight = weight;
268	}
269
270	void Event::setBeamScrapingVeto(bool isScraping){
271	isBeamScraping = isScraping;
272	}
273
274	const VertexPointer Event::PrimaryVertex() const {
275	return goodVertices.front();
276	}
277
278	const VertexCollection& Event::Vertices() const {
279	return vertices;
280	}
281
282	const VertexCollection& Event::GoodVertices() const {
283	return goodVertices;
284	}
285
286	const TrackCollection& Event::Tracks() const {
287	return tracks;
288	}
289
290	const ElectronCollection& Event::Electrons() const {
291	return allElectrons;
292	}
293
294	const ElectronCollection& Event::GoodElectrons() const {
295	return goodElectrons;
296	}
297
298	const ElectronCollection& Event::GoodIsolatedElectrons() const {
299	return goodIsolatedElectrons;
300	}
301
302	const ElectronCollection& Event::GoodPFIsolatedElectrons() const {
303	return goodPFIsolatedElectrons;
304	}
305
306	const ElectronCollection& Event::QCDElectrons() const{
307	return qcdElectrons;
308	}
309
310	const ElectronCollection& Event::LoosePFElectrons() const{
311	return loosePFElectrons;
312	}
313
314	const JetCollection& Event::Jets() const {
315	return allJets;
316	}
317
318	const JetCollection& Event::GenJets() const {
319	return genJets;
320	}
321
322
323	const JetCollection& Event::GoodJets() const {
324	return goodJets;
325	}
326
327	const JetCollection& Event::GoodBJets() const {
328	return goodBJets;
329	}
330
331	const MuonCollection& Event::Muons() const {
332	return allMuons;
333	}
334
335	const MuonCollection& Event::GoodMuons() const {
336	return goodMuons;
337	}
338
339	const MuonCollection& Event::GoodIsolatedMuons() const {
340	return goodIsolatedMuons;
341	}
342
343	const MCParticleCollection& Event::GenParticles() const {
344	return genParticles;
345	}
346
347	const METPointer Event::MET() const {
348	return met;
349	}
350
351	unsigned long Event::runnumber() const {
352	return runNumber;
353	}
354
355	unsigned long Event::eventnumber() const {
356	return eventNumber;
357	}
358
359	unsigned long Event::localnumber() const {
360	return localEventNumber;
361	}
362
363	unsigned long Event::lumiblock() const {
364	return lumiBlock;
365	}
366
367	float Event::weight() const {
368	return eventWeight;
369	}
370
371	void Event::inspect() const {
372	cout << "run " << runNumber << ", event number " << eventNumber << ", lumi section " << lumiBlock << endl;
373
374	cout << "number of tracks: " << tracks.size() << endl;
375	cout << "number of high purity tracks: " << numberOfHighPurityTracks << endl;
376
377	cout << "number of jets: " << allJets.size() << endl;
378	EventContentPrinter::printJets(allJets);
379	cout << "number of good jets: " << goodJets.size() << endl;
380	EventContentPrinter::printJets(goodJets);
381
382	cout << "number of good isolated electrons: " << goodIsolatedElectrons.size() << endl;
383	EventContentPrinter::printElectrons(goodIsolatedElectrons);
384
385	cout << "number of good electrons: " << goodElectrons.size() << endl;
386	EventContentPrinter::printElectrons(goodElectrons);
387
388	cout << "number of electrons: " << allElectrons.size() << endl;
389	EventContentPrinter::printElectrons(allElectrons);
390	}
391
392	bool Event::HLT(HLTriggers::value trigger) const{
393	if (trigger >= (int) HLTs->size()) {
394	static bool showMsg = true;
395	if (showMsg) {
396	cout << "Seeking trigger # " << trigger << " but only ";
397	cout << HLTs->size() << " triggers in ntuple\n";
398	showMsg = false;
399	}
400	return false;
401	}
402	return (HLTs->at(trigger) > 0);
403	}
404
405	void Event::setGenNumberOfPileUpVertices(unsigned int pileup){
406	genNumberOfPileUpVertices = pileup;
407	}
408
409	float Event::numberOfGeneratedPileUpVertices() const{
410	return genNumberOfPileUpVertices;
411	}
412
413	}