src/RecoObjects/Electron.cpp

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

#include "../../interface/RecoObjects/Electron.h"
#include <assert.h>

namespace BAT {

static const float initialBigValue = 123456789;
Electron::Electron() :
    Lepton(),
    usedAlgorithm(ElectronAlgorithm::Calo),
    robustLooseId(false),
    robustTightId(false),
    superCluser_Eta(initialBigValue),
    ecal_Isolation(initialBigValue),
    hcal_Isolation(initialBigValue),
    tracker_Isolation(initialBigValue),
    innerLayerMissingHits_(initialBigValue),
    sigma_IEtaIEta(0),
    dPhi_In(0),
    dEta_In(0),
    hadOverEm(0),
    gsfTrack(),
    closesTrackID(-1),
    sharedFractionInnerHits(0),
    dCotThetaToNextTrack(0),
    distToNextTrack(0)
    {
}

Electron::Electron(float energy, float px, float py, float pz) :
    Lepton(energy, px, py, pz),
    usedAlgorithm(ElectronAlgorithm::Calo),
    robustLooseId(false),
    robustTightId(false),
    superCluser_Eta(initialBigValue),
    ecal_Isolation(initialBigValue),
    hcal_Isolation(initialBigValue),
    tracker_Isolation(initialBigValue),
    innerLayerMissingHits_(initialBigValue),
    sigma_IEtaIEta(0),
    dPhi_In(0),
    dEta_In(0),
    hadOverEm(0),
    gsfTrack(),
    closesTrackID(-1),
    sharedFractionInnerHits(0),
    dCotThetaToNextTrack(0),
    distToNextTrack(0)
    {
}

Electron::~Electron() {
}

float Electron::superClusterEta() const {
    return superCluser_Eta;
}
float Electron::ecalIsolation() const {
    return ecal_Isolation;
}

float Electron::hcalIsolation() const {
    return hcal_Isolation;
}

float Electron::trackerIsolation() const {
    return tracker_Isolation;
}

float Electron::relativeIsolation() const {
    return (ecal_Isolation + hcal_Isolation + tracker_Isolation) / this->et();
}

bool Electron::isIsolated() const {
    return relativeIsolation() < 0.1;
}

bool Electron::isHEEPIsolated() const {
    if (isInBarrelRegion())
        return (ecal_Isolation + hcal_Isolation) < 2 + 0.03 * et();
    else if (isInEndCapRegion() && et() < 50)
        return (ecal_Isolation + hcal_Isolation) < 2.5;
    else if (isInEndCapRegion() && et() >= 50)
        return (ecal_Isolation + hcal_Isolation) < 2.5 + 0.03 * (et() - 50);
    else
        return false;
}

ElectronAlgorithm::value Electron::getUsedAlgorithm() const {
    return usedAlgorithm;
}

void Electron::setEcalIsolation(float isolation) {
    ecal_Isolation = isolation;
}

void Electron::setHcalIsolation(float isolation) {
    hcal_Isolation = isolation;
}

void Electron::setTrackerIsolation(float isolation) {
    tracker_Isolation = isolation;
}

void Electron::setSuperClusterEta(float eta) {
    superCluser_Eta = eta;
}

void Electron::setRobustLooseID(bool id) {
    robustLooseId = id;
}

void Electron::setRobustTightID(bool id) {
    robustTightId = id;
}

void Electron::setSigmaIEtaIEta(float sigma) {
    sigma_IEtaIEta = sigma;
}

void Electron::setDPhiIn(float dphi) {
    dPhi_In = dphi;
}

void Electron::setDEtaIn(float deta) {
    dEta_In = deta;
}

void Electron::setHadOverEm(float HoverE) {
    hadOverEm = HoverE;
}

bool Electron::isLoose() const {
    bool passesEt = et() > 20;
    bool passesEta = fabs(eta()) < 2.5;
                bool isolated = isPFIsolated();
                bool notInCrack = isInCrack() == false;
    return passesEt && passesEta && isolated && notInCrack && VBTF_W95_ElectronID();

}

bool Electron::isGood(const float unused) const {
    bool passesPt = pt() > 45.0;
    bool passesEta = fabs(eta()) < 2.5 && !isInCrack();

    bool passesD0 = false;
    if (usedAlgorithm == ElectronAlgorithm::Calo)
        passesD0 = fabs(d0_wrtBeamSpot()) < 0.02;//cm
    else
        // use d0 wrt primary vertex for
        passesD0 = fabs(d0()) < 0.02; //cm

    bool passesDistanceToPV = fabs(zDistanceToPrimaryVertex) < 1;
    bool passesID = VBTF_W70_ElectronID();
    return passesPt && passesEta && passesD0 && passesID && passesDistanceToPV;
}

bool Electron::isQCDElectron(const float minEt) const {
    bool passesEt = et() > minEt;
    bool passesEta = fabs(eta()) < 2.5 && !isInCrack();

    bool passesD0 = false;
    if (usedAlgorithm == ElectronAlgorithm::Calo)
        passesD0 = fabs(d0_wrtBeamSpot()) < 0.02;//cm
    else
        passesD0 = fabs(d0()) < 0.02;//cm

    bool passesDistanceToPV = fabs(zDistanceToPrimaryVertex) < 1;
    bool passesID = QCD_AntiID_W70();
    return passesEt && passesEta && passesD0 && passesID && passesDistanceToPV;
}

bool Electron::isInBarrelRegion() const {
    return fabs(superClusterEta()) < 1.4442;
}

bool Electron::isInCrack() const {
    return !isInBarrelRegion() && !isInEndCapRegion();
}

bool Electron::isInEndCapRegion() const {
    return fabs(superClusterEta()) > 1.5660;
}

bool Electron::isFromConversion() const {
    return innerLayerMissingHits_ > 0;
}

bool Electron::isTaggedAsConversion(float maxDist, float maxDCotTheta) const {
    return fabs(distToNextTrack) < maxDist && fabs(dCotThetaToNextTrack) < maxDCotTheta;
}

/* Electron ID cuts (without isolation) from:
 * https://twiki.cern.ch/twiki/bin/view/CMS/SimpleCutBasedEleID#Cuts_for_use_on_2010_data
 */
bool Electron::VBTF_W70_ElectronID() const {
    if (isInBarrelRegion())
        return getVBTF_W70_ElectronID_Barrel();
    else if (isInEndCapRegion())
        return getVBTF_W70_ElectronID_Endcap();
    else
        // in crack
        return false;
}

bool Electron::getVBTF_W70_ElectronID_Barrel() const {
    bool passesSigmaIEta = sigma_IEtaIEta < 0.01;
    bool passesDPhiIn = fabs(dPhi_In) < 0.03;
    bool passesDEtaIn = fabs(dEta_In) < 0.004;
    bool passesHadOverEm = hadOverEm < 0.025;
    return passesSigmaIEta && passesDPhiIn && passesDEtaIn && passesHadOverEm;
}

bool Electron::getVBTF_W70_ElectronID_Endcap() const {
    bool passesSigmaIEta = sigma_IEtaIEta < 0.03;
    bool passesDPhiIn = fabs(dPhi_In) < 0.02;
    bool passesDEtaIn = fabs(dEta_In) < 0.005;
    bool passesHadOverEm = hadOverEm < 0.025;
    return passesSigmaIEta && passesDPhiIn && passesDEtaIn && passesHadOverEm;
}

bool Electron::VBTF_W95_ElectronID() const {
    if (isInBarrelRegion())
        return getVBTF_W95_ElectronID_Barrel();
    else if (isInEndCapRegion())
        return getVBTF_W95_ElectronID_Endcap();
    else
        // in crack
        return false;
}

bool Electron::getVBTF_W95_ElectronID_Barrel() const {
    bool passesSigmaIEta = sigma_IEtaIEta < 0.01;
    bool passesDPhiIn = fabs(dPhi_In) < 0.8;
    bool passesDEtaIn = fabs(dEta_In) < 0.007;
    bool passesHadOverEm = hadOverEm < 0.15;
    return passesSigmaIEta && passesDPhiIn && passesDEtaIn && passesHadOverEm;
}

bool Electron::getVBTF_W95_ElectronID_Endcap() const {
    bool passesSigmaIEta = sigma_IEtaIEta < 0.03;
    bool passesDPhiIn = fabs(dPhi_In) < 0.7;
    bool passesDEtaIn = fabs(dEta_In) < 0.01;
    bool passesHadOverEm = hadOverEm < 0.07;
    return passesSigmaIEta && passesDPhiIn && passesDEtaIn && passesHadOverEm;
}

bool Electron::QCD_AntiID_W70() const {
    if (isInBarrelRegion())
        return QCD_AntiID_W70_Barrel();
    else if (isInEndCapRegion())
        return QCD_AntiID_W70_Endcap();
    else
        return false;
}

bool Electron::QCD_AntiID_W70_Barrel() const {
    bool passesSigmaIEta = sigma_IEtaIEta < 0.01;
    bool passesDPhiIn = fabs(dPhi_In) > 0.03;
    bool passesDEtaIn = fabs(dEta_In) > 0.004;
    bool passesHadOverEm = hadOverEm < 0.025;
    return passesSigmaIEta && passesDPhiIn && passesDEtaIn && passesHadOverEm;
}

bool Electron::QCD_AntiID_W70_Endcap() const {
    bool passesSigmaIEta = sigma_IEtaIEta < 0.03;
    bool passesDPhiIn = fabs(dPhi_In) > 0.02;
    bool passesDEtaIn = fabs(dEta_In) > 0.005;
    bool passesHadOverEm = hadOverEm < 0.025;
    return passesSigmaIEta && passesDPhiIn && passesDEtaIn && passesHadOverEm;
}

float Electron::sigmaIEtaIEta() const {
    return sigma_IEtaIEta;
}

float Electron::dPhiIn() const {
    return dPhi_In;
}

float Electron::dEtaIn() const {
    return dEta_In;
}

float Electron::HadOverEm() const {
    return hadOverEm;
}

float Electron::HEEPet() const {
    return energy() * sin(fourvector.Theta());
}

bool Electron::RobustLooseID() const {
    return robustLooseId;
}

bool Electron::RobustTightID() const {
    return robustTightId;
}

void Electron::setNumberOfMissingInnerLayerHits(float missingHits) {
    innerLayerMissingHits_ = missingHits;
}

unsigned short Electron::getClosestJetIndex(const JetCollection& jets) const {
    unsigned short idOfClosest = 999;
    float closestDR = 999.;
    for (unsigned short index = 0; index < jets.size(); ++index) {
        float DR = deltaR(jets.at(index));
        if (DR < closestDR) {
            closestDR = DR;
            idOfClosest = index;
        }
    }
    return idOfClosest;
}

void Electron::setUsedAlgorithm(ElectronAlgorithm::value algo) {
    usedAlgorithm = algo;
}

void Electron::setGSFTrack(const TrackPointer track) {
    gsfTrack = track;
}

const TrackPointer Electron::GSFTrack() const {
    return gsfTrack;
}

void Electron::setClosestTrackID(int trackID) {
    closesTrackID = trackID;
}

int Electron::closestCTFTrackID() const {
    return closesTrackID;
}

void Electron::setSharedFractionInnerHits(float hits) {
    sharedFractionInnerHits = hits;
}

float Electron::shFracInnerLayer() const {
    return sharedFractionInnerHits;
}

void Electron::setDistToNextTrack(float dist) {
    distToNextTrack = dist;
}

void Electron::setDCotThetaToNextTrack(float dCotTheta) {
    dCotThetaToNextTrack = dCotTheta;
}

bool Electron::isPFIsolated() const {
    return pfIsolation() < 0.1;
}

ElectronAlgorithm::value Electron::algorithm() const {
    return usedAlgorithm;
}

float Electron::innerLayerMissingHits() const {
    return innerLayerMissingHits_;
}

float Electron::distToClosestTrack() const {
    return distToNextTrack;
}

float Electron::dCotThetaToClosestTrack() const {
    return dCotThetaToNextTrack;
}

}
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	* Electron.cpp
3	*
4	* Created on: Jun 25, 2010
5	* Author: lkreczko
6	*/
7
8	#include "../../interface/RecoObjects/Electron.h"
9	#include <assert.h>
10
11	namespace BAT {
12
13	static const float initialBigValue = 123456789;
14	Electron::Electron() :
15	Lepton(),
16	usedAlgorithm(ElectronAlgorithm::Calo),
17	robustLooseId(false),
18	robustTightId(false),
19	superCluser_Eta(initialBigValue),
20	ecal_Isolation(initialBigValue),
21	hcal_Isolation(initialBigValue),
22	tracker_Isolation(initialBigValue),
23	innerLayerMissingHits_(initialBigValue),
24	sigma_IEtaIEta(0),
25	dPhi_In(0),
26	dEta_In(0),
27	hadOverEm(0),
28	gsfTrack(),
29	closesTrackID(-1),
30	sharedFractionInnerHits(0),
31	dCotThetaToNextTrack(0),
32	distToNextTrack(0)
33	{
34	}
35
36	Electron::Electron(float energy, float px, float py, float pz) :
37	Lepton(energy, px, py, pz),
38	usedAlgorithm(ElectronAlgorithm::Calo),
39	robustLooseId(false),
40	robustTightId(false),
41	superCluser_Eta(initialBigValue),
42	ecal_Isolation(initialBigValue),
43	hcal_Isolation(initialBigValue),
44	tracker_Isolation(initialBigValue),
45	innerLayerMissingHits_(initialBigValue),
46	sigma_IEtaIEta(0),
47	dPhi_In(0),
48	dEta_In(0),
49	hadOverEm(0),
50	gsfTrack(),
51	closesTrackID(-1),
52	sharedFractionInnerHits(0),
53	dCotThetaToNextTrack(0),
54	distToNextTrack(0)
55	{
56	}
57
58	Electron::~Electron() {
59	}
60
61	float Electron::superClusterEta() const {
62	return superCluser_Eta;
63	}
64	float Electron::ecalIsolation() const {
65	return ecal_Isolation;
66	}
67
68	float Electron::hcalIsolation() const {
69	return hcal_Isolation;
70	}
71
72	float Electron::trackerIsolation() const {
73	return tracker_Isolation;
74	}
75
76	float Electron::relativeIsolation() const {
77	return (ecal_Isolation + hcal_Isolation + tracker_Isolation) / this->et();
78	}
79
80	bool Electron::isIsolated() const {
81	return relativeIsolation() < 0.1;
82	}
83
84	bool Electron::isHEEPIsolated() const {
85	if (isInBarrelRegion())
86	return (ecal_Isolation + hcal_Isolation) < 2 + 0.03 * et();
87	else if (isInEndCapRegion() && et() < 50)
88	return (ecal_Isolation + hcal_Isolation) < 2.5;
89	else if (isInEndCapRegion() && et() >= 50)
90	return (ecal_Isolation + hcal_Isolation) < 2.5 + 0.03 * (et() - 50);
91	else
92	return false;
93	}
94
95	ElectronAlgorithm::value Electron::getUsedAlgorithm() const {
96	return usedAlgorithm;
97	}
98
99	void Electron::setEcalIsolation(float isolation) {
100	ecal_Isolation = isolation;
101	}
102
103	void Electron::setHcalIsolation(float isolation) {
104	hcal_Isolation = isolation;
105	}
106
107	void Electron::setTrackerIsolation(float isolation) {
108	tracker_Isolation = isolation;
109	}
110
111	void Electron::setSuperClusterEta(float eta) {
112	superCluser_Eta = eta;
113	}
114
115	void Electron::setRobustLooseID(bool id) {
116	robustLooseId = id;
117	}
118
119	void Electron::setRobustTightID(bool id) {
120	robustTightId = id;
121	}
122
123	void Electron::setSigmaIEtaIEta(float sigma) {
124	sigma_IEtaIEta = sigma;
125	}
126
127	void Electron::setDPhiIn(float dphi) {
128	dPhi_In = dphi;
129	}
130
131	void Electron::setDEtaIn(float deta) {
132	dEta_In = deta;
133	}
134
135	void Electron::setHadOverEm(float HoverE) {
136	hadOverEm = HoverE;
137	}
138
139	bool Electron::isLoose() const {
140	bool passesEt = et() > 20;
141	bool passesEta = fabs(eta()) < 2.5;
142	bool isolated = isPFIsolated();
143	bool notInCrack = isInCrack() == false;
144	return passesEt && passesEta && isolated && notInCrack && VBTF_W95_ElectronID();
145
146	}
147
148	bool Electron::isGood(const float unused) const {
149	bool passesPt = pt() > 45.0;
150	bool passesEta = fabs(eta()) < 2.5 && !isInCrack();
151
152	bool passesD0 = false;
153	if (usedAlgorithm == ElectronAlgorithm::Calo)
154	passesD0 = fabs(d0_wrtBeamSpot()) < 0.02;//cm
155	else
156	// use d0 wrt primary vertex for
157	passesD0 = fabs(d0()) < 0.02; //cm
158
159	bool passesDistanceToPV = fabs(zDistanceToPrimaryVertex) < 1;
160	bool passesID = VBTF_W70_ElectronID();
161	return passesPt && passesEta && passesD0 && passesID && passesDistanceToPV;
162	}
163
164	bool Electron::isQCDElectron(const float minEt) const {
165	bool passesEt = et() > minEt;
166	bool passesEta = fabs(eta()) < 2.5 && !isInCrack();
167
168	bool passesD0 = false;
169	if (usedAlgorithm == ElectronAlgorithm::Calo)
170	passesD0 = fabs(d0_wrtBeamSpot()) < 0.02;//cm
171	else
172	passesD0 = fabs(d0()) < 0.02;//cm
173
174	bool passesDistanceToPV = fabs(zDistanceToPrimaryVertex) < 1;
175	bool passesID = QCD_AntiID_W70();
176	return passesEt && passesEta && passesD0 && passesID && passesDistanceToPV;
177	}
178
179	bool Electron::isInBarrelRegion() const {
180	return fabs(superClusterEta()) < 1.4442;
181	}
182
183	bool Electron::isInCrack() const {
184	return !isInBarrelRegion() && !isInEndCapRegion();
185	}
186
187	bool Electron::isInEndCapRegion() const {
188	return fabs(superClusterEta()) > 1.5660;
189	}
190
191	bool Electron::isFromConversion() const {
192	return innerLayerMissingHits_ > 0;
193	}
194
195	bool Electron::isTaggedAsConversion(float maxDist, float maxDCotTheta) const {
196	return fabs(distToNextTrack) < maxDist && fabs(dCotThetaToNextTrack) < maxDCotTheta;
197	}
198
199	/* Electron ID cuts (without isolation) from:
200	* https://twiki.cern.ch/twiki/bin/view/CMS/SimpleCutBasedEleID#Cuts_for_use_on_2010_data
201	*/
202	bool Electron::VBTF_W70_ElectronID() const {
203	if (isInBarrelRegion())
204	return getVBTF_W70_ElectronID_Barrel();
205	else if (isInEndCapRegion())
206	return getVBTF_W70_ElectronID_Endcap();
207	else
208	// in crack
209	return false;
210	}
211
212	bool Electron::getVBTF_W70_ElectronID_Barrel() const {
213	bool passesSigmaIEta = sigma_IEtaIEta < 0.01;
214	bool passesDPhiIn = fabs(dPhi_In) < 0.03;
215	bool passesDEtaIn = fabs(dEta_In) < 0.004;
216	bool passesHadOverEm = hadOverEm < 0.025;
217	return passesSigmaIEta && passesDPhiIn && passesDEtaIn && passesHadOverEm;
218	}
219
220	bool Electron::getVBTF_W70_ElectronID_Endcap() const {
221	bool passesSigmaIEta = sigma_IEtaIEta < 0.03;
222	bool passesDPhiIn = fabs(dPhi_In) < 0.02;
223	bool passesDEtaIn = fabs(dEta_In) < 0.005;
224	bool passesHadOverEm = hadOverEm < 0.025;
225	return passesSigmaIEta && passesDPhiIn && passesDEtaIn && passesHadOverEm;
226	}
227
228	bool Electron::VBTF_W95_ElectronID() const {
229	if (isInBarrelRegion())
230	return getVBTF_W95_ElectronID_Barrel();
231	else if (isInEndCapRegion())
232	return getVBTF_W95_ElectronID_Endcap();
233	else
234	// in crack
235	return false;
236	}
237
238	bool Electron::getVBTF_W95_ElectronID_Barrel() const {
239	bool passesSigmaIEta = sigma_IEtaIEta < 0.01;
240	bool passesDPhiIn = fabs(dPhi_In) < 0.8;
241	bool passesDEtaIn = fabs(dEta_In) < 0.007;
242	bool passesHadOverEm = hadOverEm < 0.15;
243	return passesSigmaIEta && passesDPhiIn && passesDEtaIn && passesHadOverEm;
244	}
245
246	bool Electron::getVBTF_W95_ElectronID_Endcap() const {
247	bool passesSigmaIEta = sigma_IEtaIEta < 0.03;
248	bool passesDPhiIn = fabs(dPhi_In) < 0.7;
249	bool passesDEtaIn = fabs(dEta_In) < 0.01;
250	bool passesHadOverEm = hadOverEm < 0.07;
251	return passesSigmaIEta && passesDPhiIn && passesDEtaIn && passesHadOverEm;
252	}
253
254	bool Electron::QCD_AntiID_W70() const {
255	if (isInBarrelRegion())
256	return QCD_AntiID_W70_Barrel();
257	else if (isInEndCapRegion())
258	return QCD_AntiID_W70_Endcap();
259	else
260	return false;
261	}
262
263	bool Electron::QCD_AntiID_W70_Barrel() const {
264	bool passesSigmaIEta = sigma_IEtaIEta < 0.01;
265	bool passesDPhiIn = fabs(dPhi_In) > 0.03;
266	bool passesDEtaIn = fabs(dEta_In) > 0.004;
267	bool passesHadOverEm = hadOverEm < 0.025;
268	return passesSigmaIEta && passesDPhiIn && passesDEtaIn && passesHadOverEm;
269	}
270
271	bool Electron::QCD_AntiID_W70_Endcap() const {
272	bool passesSigmaIEta = sigma_IEtaIEta < 0.03;
273	bool passesDPhiIn = fabs(dPhi_In) > 0.02;
274	bool passesDEtaIn = fabs(dEta_In) > 0.005;
275	bool passesHadOverEm = hadOverEm < 0.025;
276	return passesSigmaIEta && passesDPhiIn && passesDEtaIn && passesHadOverEm;
277	}
278
279	float Electron::sigmaIEtaIEta() const {
280	return sigma_IEtaIEta;
281	}
282
283	float Electron::dPhiIn() const {
284	return dPhi_In;
285	}
286
287	float Electron::dEtaIn() const {
288	return dEta_In;
289	}
290
291	float Electron::HadOverEm() const {
292	return hadOverEm;
293	}
294
295	float Electron::HEEPet() const {
296	return energy() * sin(fourvector.Theta());
297	}
298
299	bool Electron::RobustLooseID() const {
300	return robustLooseId;
301	}
302
303	bool Electron::RobustTightID() const {
304	return robustTightId;
305	}
306
307	void Electron::setNumberOfMissingInnerLayerHits(float missingHits) {
308	innerLayerMissingHits_ = missingHits;
309	}
310
311	unsigned short Electron::getClosestJetIndex(const JetCollection& jets) const {
312	unsigned short idOfClosest = 999;
313	float closestDR = 999.;
314	for (unsigned short index = 0; index < jets.size(); ++index) {
315	float DR = deltaR(jets.at(index));
316	if (DR < closestDR) {
317	closestDR = DR;
318	idOfClosest = index;
319	}
320	}
321	return idOfClosest;
322	}
323
324	void Electron::setUsedAlgorithm(ElectronAlgorithm::value algo) {
325	usedAlgorithm = algo;
326	}
327
328	void Electron::setGSFTrack(const TrackPointer track) {
329	gsfTrack = track;
330	}
331
332	const TrackPointer Electron::GSFTrack() const {
333	return gsfTrack;
334	}
335
336	void Electron::setClosestTrackID(int trackID) {
337	closesTrackID = trackID;
338	}
339
340	int Electron::closestCTFTrackID() const {
341	return closesTrackID;
342	}
343
344	void Electron::setSharedFractionInnerHits(float hits) {
345	sharedFractionInnerHits = hits;
346	}
347
348	float Electron::shFracInnerLayer() const {
349	return sharedFractionInnerHits;
350	}
351
352	void Electron::setDistToNextTrack(float dist) {
353	distToNextTrack = dist;
354	}
355
356	void Electron::setDCotThetaToNextTrack(float dCotTheta) {
357	dCotThetaToNextTrack = dCotTheta;
358	}
359
360	bool Electron::isPFIsolated() const {
361	return pfIsolation() < 0.1;
362	}
363
364	ElectronAlgorithm::value Electron::algorithm() const {
365	return usedAlgorithm;
366	}
367
368	float Electron::innerLayerMissingHits() const {
369	return innerLayerMissingHits_;
370	}
371
372	float Electron::distToClosestTrack() const {
373	return distToNextTrack;
374	}
375
376	float Electron::dCotThetaToClosestTrack() const {
377	return dCotThetaToNextTrack;
378	}
379
380	}