Tools/test/TestObjectFactory.cpp

/*
 * TestObjectFactory.cpp
 *
 *  Created on: 28 Sep 2010
 *      Author: kreczko
 */

#include "TestObjectFactory.h"
#include <iostream>

using namespace std;
using namespace BAT;

double const TestObjectFactory::goodVertexMaximalAbsoluteRho = 2.0;
double const TestObjectFactory::goodVertexMinimalNumberOfDegreesOfFreedom = 4;
double const TestObjectFactory::goodVertexMaximalAbsoluteZPosition = 24.;//cm

double const TestObjectFactory::isolatedElectronMaximalRelativeIsolation = 0.1;
double const TestObjectFactory::goodElectronMaximalAbsoluteEta = 2.1;
double const TestObjectFactory::goodElectronMinimalEt = 30.;
double const TestObjectFactory::goodElectronMaximalDistanceFromInteractionPoint = 0.02;//cm
double const TestObjectFactory::MaximalNumberOfMissingInnerLayerHitsBeforeCalledConversion = 0;
double const TestObjectFactory::MinimalDistanceToNextTrackBeforeCalledConversion = 0.2;
double const TestObjectFactory::MinimalDCotToNextTrackBeforeCalledConversion = 0.2;
double const TestObjectFactory::looseElectronMaximalAbsoluteEta = 2.5;
double const TestObjectFactory::looseElectronMinimalEt = 25.;
double const TestObjectFactory::looseIsolatedElectronMaximalRelativeIsolation = 1.0;

double const TestObjectFactory::goodJetMaximalAbsoluteEta = 2.4;
double const TestObjectFactory::goodJetMinimalPt = 30;
double const TestObjectFactory::goodJetMinimalElectromagneticFraction = 0.01;
double const TestObjectFactory::goodJetMinimalNumberOfRecHitsContaining90PercentOfTheJetEnergy = 1;
double const TestObjectFactory::goodJetMaximalFractionOfEnergyIntheHottestHPDReadout = 0.98;

double const TestObjectFactory::goodMuonMinimalPt = 15.;
double const TestObjectFactory::goodMuonMaximalAbsoluteEta = 2.5;
double const TestObjectFactory::isolatedMuonMaximalRelativeIsolation = 0.2;

TestObjectFactory::TestObjectFactory() {

}

TestObjectFactory::~TestObjectFactory() {
}

VertexPointer TestObjectFactory::goodVertex() {
    VertexPointer pv = VertexPointer(new Vertex());

    pv->setFake(false);
    pv->setDegreesOfFreedom(TestObjectFactory::goodVertexMinimalNumberOfDegreesOfFreedom);
    pv->setRho(TestObjectFactory::goodVertexMaximalAbsoluteRho * 0.9);
    pv->setZPosition(TestObjectFactory::goodVertexMaximalAbsoluteZPosition);

    assert(pv->isGood());

    return pv;
}

VertexPointer TestObjectFactory::badFakeVertex() {
    VertexPointer pv(TestObjectFactory::goodVertex());

    pv->setFake(true);

    assert(pv->isGood() == false);

    return pv;
}

VertexPointer TestObjectFactory::badNDOFVertex() {
    VertexPointer pv(TestObjectFactory::goodVertex());

    pv->setDegreesOfFreedom(TestObjectFactory::goodVertexMinimalNumberOfDegreesOfFreedom - 1);

    assert(pv->isGood() == false);

    return pv;
}

VertexPointer TestObjectFactory::badRhoVertex() {
    VertexPointer pv(TestObjectFactory::goodVertex());

    pv->setRho(TestObjectFactory::goodVertexMaximalAbsoluteRho * 1.1);

    assert(pv->isGood() == false);

    return pv;
}

VertexPointer TestObjectFactory::badZPositionVertex() {
    VertexPointer pv(TestObjectFactory::goodVertex());

    pv->setZPosition(TestObjectFactory::goodVertexMaximalAbsoluteZPosition * 1.1);

    assert(pv->isGood() == false);

    return pv;
}

ElectronPointer TestObjectFactory::goodCaloElectron() {
    ElectronPointer electron = ElectronPointer(new Electron(100., 99., 13., 5.));
    electron->setUsedAlgorithm(ElectronAlgorithm::Calo);
    electron->setSuperClusterEta(0);
    electron->setD0_wrtBeamSpot(0);
    VertexPointer pv = TestObjectFactory::goodVertex();
    electron->setZDistanceToPrimaryVertex(0);

    electron->setDEtaIn(0);
    electron->setDPhiIn(0);
    electron->setHadOverEm(0);
    electron->setSigmaIEtaIEta(0);

    electron->setNumberOfMissingInnerLayerHits(0);
    electron->setDCotThetaToNextTrack(0.5);
    electron->setDistToNextTrack(0.5);
    if (electron->isGood() == false) {
        cout << "Et " << electron->et() << endl;
        cout << "Eta " << electron->eta() << endl;
        cout << "VBTF 70 " << electron->VBTF_W70_ElectronID() << endl;
        cout << "d0 " << electron->d0_wrtBeamSpot() << endl;
        cout << "Et " << electron->et() << endl;
    }
    assert(electron->isGood());
    assert(electron->isFromConversion() == false);
    assert(electron->isIsolated() == false);
    return electron;
}

ElectronPointer TestObjectFactory::goodIsolatedElectron() {
    ElectronPointer electron = TestObjectFactory::goodCaloElectron();
    electron->setTrackerIsolation(0.4);
    electron->setEcalIsolation(0.3);
    electron->setHcalIsolation(0.5);

    assert(electron->isIsolated());
    assert(electron->isGood());
    assert(electron->isFromConversion() == false);
    assert(electron->isTaggedAsConversion(0.02,0.02) == false);
    return electron;
}

ElectronPointer TestObjectFactory::goodIsolatedElectron2() {
    ElectronPointer electron = TestObjectFactory::goodIsolatedElectron();
    ElectronPointer electron2 = TestObjectFactory::goodIsolatedElectron();
    FourVector vec = electron->getFourVector();
    vec.SetPx(vec.Px() - 20);
    vec.SetPy(-vec.Py());
    vec.SetPz(-vec.Pz());
    electron2->setFourVector(vec);
    //Z mass requirement
    assert(electron->invariantMass(electron2) > 80);
    assert(electron->invariantMass(electron2) < 100);
    assert(electron2->isIsolated());
    assert(electron2->isGood());
    return electron2;
}

ElectronPointer TestObjectFactory::badEtElectron() {
    ElectronPointer badEtElectron(new Electron(20., 10., 0., 5.));
    badEtElectron->setD0(0.01);
    badEtElectron->setSuperClusterEta(1);

    assert(fabs(badEtElectron->eta()) < TestObjectFactory::goodElectronMaximalAbsoluteEta);
    assert(fabs(badEtElectron->d0()) < TestObjectFactory::goodElectronMaximalDistanceFromInteractionPoint);
    //and fails the selected
    assert(badEtElectron->et() < TestObjectFactory::goodElectronMinimalEt);
    return badEtElectron;
}

ElectronPointer TestObjectFactory::badEtaElectron() {
    ElectronPointer badEtaElectron(new Electron(400., 50., 50., 380));
    badEtaElectron->setD0(0.01);
    badEtaElectron->setSuperClusterEta(1);

    assert(fabs(badEtaElectron->eta()) > TestObjectFactory::goodElectronMaximalAbsoluteEta);
    assert(fabs(badEtaElectron->d0()) < TestObjectFactory::goodElectronMaximalDistanceFromInteractionPoint);
    assert(badEtaElectron->et() > TestObjectFactory::goodElectronMinimalEt);

    return badEtaElectron;
}

ElectronPointer TestObjectFactory::badInCrackElectron() {
    ElectronPointer badInCrackElectron(TestObjectFactory::goodCaloElectron());
    badInCrackElectron->setSuperClusterEta(1.5);

    assert(badInCrackElectron->isInCrack());

    return badInCrackElectron;
}

ElectronPointer TestObjectFactory::badD0Electron() {
    ElectronPointer badD0Electron(TestObjectFactory::goodCaloElectron());
    badD0Electron->setD0_wrtBeamSpot(300.);
    badD0Electron->setD0(300.);

    assert(fabs(badD0Electron->d0()) > goodElectronMaximalDistanceFromInteractionPoint);
    assert(fabs(badD0Electron->d0_wrtBeamSpot()) > goodElectronMaximalDistanceFromInteractionPoint);

    return badD0Electron;
}

ElectronPointer TestObjectFactory::electronWithMissingInnerLayerHit() {
    ElectronPointer electronWithMissingInnerLayerHit(TestObjectFactory::goodCaloElectron());
    electronWithMissingInnerLayerHit->setNumberOfMissingInnerLayerHits(1);

    assert(electronWithMissingInnerLayerHit->innerLayerMissingHits() > MaximalNumberOfMissingInnerLayerHitsBeforeCalledConversion);
    return electronWithMissingInnerLayerHit;

}

ElectronPointer TestObjectFactory::electronWithMatchingPartnerTrack() {
    ElectronPointer electronWithMatchingPartnerTrack(TestObjectFactory::goodCaloElectron());
    electronWithMatchingPartnerTrack->setDCotThetaToNextTrack(0.1);
    electronWithMatchingPartnerTrack->setDistToNextTrack(0.01);

    assert(electronWithMatchingPartnerTrack->distToClosestTrack() < TestObjectFactory::MinimalDistanceToNextTrackBeforeCalledConversion);
    assert(electronWithMatchingPartnerTrack->dCotThetaToClosestTrack() < TestObjectFactory::MinimalDCotToNextTrackBeforeCalledConversion);

    return electronWithMatchingPartnerTrack;
}

ElectronPointer TestObjectFactory::goodLooseElectron() {
    ElectronPointer looseElectron(new Electron(100., 79., -13., -5.));
    looseElectron->setSigmaIEtaIEta(0.009);
    looseElectron->setDPhiIn(0.7);
    looseElectron->setDEtaIn(0.006);
    looseElectron->setHadOverEm(0.14);
    looseElectron->setSuperClusterEta(1);
    looseElectron->setEcalIsolation(0);
    looseElectron->setTrackerIsolation(0);
    looseElectron->setHcalIsolation(0);

    looseElectron->setNumberOfMissingInnerLayerHits(0);
    looseElectron->setD0(0);
    looseElectron->setSuperClusterEta(0);

    assert(looseElectron->isGood() == false);
    assert(looseElectron->isLoose());

    return looseElectron;
}

ElectronPointer TestObjectFactory::badLooseElectronNoID() {
    ElectronPointer badLooseElectronNoID(goodLooseElectron());
    badLooseElectronNoID->setHcalIsolation(0.5);
    badLooseElectronNoID->setEcalIsolation(0.3);
    badLooseElectronNoID->setTrackerIsolation(0.4);
    badLooseElectronNoID->setSigmaIEtaIEta(0.009 + 2);

    assert(badLooseElectronNoID->VBTF_W95_ElectronID() == false);

    return badLooseElectronNoID;
}

ElectronPointer TestObjectFactory::badElectronNoID() {
    ElectronPointer badElectronNoID(TestObjectFactory::goodCaloElectron());
    badElectronNoID->setHcalIsolation(0.5);
    badElectronNoID->setEcalIsolation(0.3);
    badElectronNoID->setTrackerIsolation(0.4);
    badElectronNoID->setSigmaIEtaIEta(0.009 + 2);

    assert(badElectronNoID->VBTF_W70_ElectronID() == false);

    return badElectronNoID;
}

JetPointer TestObjectFactory::goodCaloJet() {
    JetPointer goodJet(new Jet(290., 200., 200., 0.));
    goodJet->setEMF(0.1);
    goodJet->setN90Hits(2.);
    goodJet->setFHPD(0.5);

    assert(goodJet->isGood());

    return goodJet;
}

JetPointer TestObjectFactory::badEMFCaloJet() {
    JetPointer badEMFJet(TestObjectFactory::goodCaloJet());

    badEMFJet->setEMF(goodJetMinimalElectromagneticFraction - 0.1);

    assert(badEMFJet->isGood() == false);

    return badEMFJet;
}

JetPointer TestObjectFactory::badN90CaloJet() {
    JetPointer badN90Jet(TestObjectFactory::goodCaloJet());

    badN90Jet->setN90Hits(TestObjectFactory::goodJetMinimalNumberOfRecHitsContaining90PercentOfTheJetEnergy - 1);

    assert(badN90Jet->isGood() == false);

    return badN90Jet;
}

JetPointer TestObjectFactory::badfHPDCaloJet() {
    JetPointer badfHPDJet(TestObjectFactory::goodCaloJet());

    badfHPDJet->setFHPD(TestObjectFactory::goodJetMaximalFractionOfEnergyIntheHottestHPDReadout + 0.01);

    assert(badfHPDJet->isGood() == false);

    return badfHPDJet;
}

JetPointer TestObjectFactory::badEtCaloJet() {
    JetPointer badEtJet(TestObjectFactory::goodCaloJet());

    badEtJet->setFourVector(FourVector(20., 20., 0., 20));

    assert(badEtJet->isGood() == false);

    return badEtJet;
}

JetPointer TestObjectFactory::badEtaCaloJet() {
    JetPointer badEtJet(TestObjectFactory::goodCaloJet());

    badEtJet->setFourVector(FourVector(200., 0., 2000., 2900.));

    assert(badEtJet->isGood() == false);

    return badEtJet;
}

JetPointer TestObjectFactory::goodCaloBJetSSVHEM() {
    JetPointer goodBJet(TestObjectFactory::goodCaloJet());

    goodBJet->setDiscriminatorForBtagType(1.7 + 0.1, BtagAlgorithm::SimpleSecondaryVertexHighEffBTag);

    assert(goodBJet->isGood());
    assert(goodBJet->isBJet(BtagAlgorithm::SimpleSecondaryVertexHighEffBTag));

    return goodBJet;
}

/**
 * This depends on TestObjectFactory::goodCaloElectron()!!
 */
JetPointer TestObjectFactory::goodCaloJetCloseToCaloElectron() {
    JetPointer goodJet(TestObjectFactory::goodCaloJet());

    goodJet->setFourVector(FourVector(98., 13., 5., 100.));

    return goodJet;
}

MuonPointer TestObjectFactory::goodIsolatedMuon() {
    MuonPointer goodIsolatedMuon(new Muon(100., 99., 13., 5.));

    goodIsolatedMuon->makeGlobal(true);
    goodIsolatedMuon->setEcalIsolation(1);
    goodIsolatedMuon->setHcalIsolation(1);
    goodIsolatedMuon->setTrackerIsolation(1);

    assert(goodIsolatedMuon->isGood());
    assert(goodIsolatedMuon->isIsolated());

    return goodIsolatedMuon;
}

MuonPointer TestObjectFactory::goodNonIsolatedMuon() {
    MuonPointer goodNonIsoMuon(TestObjectFactory::goodIsolatedMuon());

    goodNonIsoMuon->setEcalIsolation(200);
    goodNonIsoMuon->setHcalIsolation(200);
    goodNonIsoMuon->setTrackerIsolation(200);

    assert(goodNonIsoMuon->isGood());
    assert(goodNonIsoMuon->isIsolated() == false);

    return goodNonIsoMuon;
}

MuonPointer TestObjectFactory::badNonGlobalMuon() {
    MuonPointer nonGlobalMuon(TestObjectFactory::goodIsolatedMuon());

    nonGlobalMuon->makeGlobal(false);

    assert(nonGlobalMuon->isGood() == false);

    return nonGlobalMuon;
}

MuonPointer TestObjectFactory::badPtMuon() {
    MuonPointer badMuonLowPt(new Muon(5., 4., 1., 1.));

    assert(badMuonLowPt->isGood() == false);

    return badMuonLowPt;
}

MuonPointer TestObjectFactory::badEtaMuon() {
    MuonPointer badEtaMu(new Muon(450., 50., 50., 444.));

    assert(badEtaMu->isGood() == false);

    return badEtaMu;
}

METPointer TestObjectFactory::goodMET() {
    METPointer goodMET(new MET(40, 30));

    assert(goodMET->isGood());

    return goodMET;
}

METPointer TestObjectFactory::badMET() {
    METPointer badMissingET(new MET(4, 3));

    assert(badMissingET->isGood() == false);

    return badMissingET;
}

Revision:	1.1.1.1 (vendor branch)
Committed:	Thu Dec 1 16:28:47 2011 UTC (13 years, 5 months ago) by dhidas
Branch:	dhidas, MAIN
CVS Tags:	START, HEAD
Changes since 1.1:	+0 -0 lines
Log Message:	osu copy modified
#	Content
1	/*
2	* TestObjectFactory.cpp
3	*
4	* Created on: 28 Sep 2010
5	* Author: kreczko
6	*/
7
8	#include "TestObjectFactory.h"
9	#include <iostream>
10
11	using namespace std;
12	using namespace BAT;
13
14	double const TestObjectFactory::goodVertexMaximalAbsoluteRho = 2.0;
15	double const TestObjectFactory::goodVertexMinimalNumberOfDegreesOfFreedom = 4;
16	double const TestObjectFactory::goodVertexMaximalAbsoluteZPosition = 24.;//cm
17
18	double const TestObjectFactory::isolatedElectronMaximalRelativeIsolation = 0.1;
19	double const TestObjectFactory::goodElectronMaximalAbsoluteEta = 2.1;
20	double const TestObjectFactory::goodElectronMinimalEt = 30.;
21	double const TestObjectFactory::goodElectronMaximalDistanceFromInteractionPoint = 0.02;//cm
22	double const TestObjectFactory::MaximalNumberOfMissingInnerLayerHitsBeforeCalledConversion = 0;
23	double const TestObjectFactory::MinimalDistanceToNextTrackBeforeCalledConversion = 0.2;
24	double const TestObjectFactory::MinimalDCotToNextTrackBeforeCalledConversion = 0.2;
25	double const TestObjectFactory::looseElectronMaximalAbsoluteEta = 2.5;
26	double const TestObjectFactory::looseElectronMinimalEt = 25.;
27	double const TestObjectFactory::looseIsolatedElectronMaximalRelativeIsolation = 1.0;
28
29	double const TestObjectFactory::goodJetMaximalAbsoluteEta = 2.4;
30	double const TestObjectFactory::goodJetMinimalPt = 30;
31	double const TestObjectFactory::goodJetMinimalElectromagneticFraction = 0.01;
32	double const TestObjectFactory::goodJetMinimalNumberOfRecHitsContaining90PercentOfTheJetEnergy = 1;
33	double const TestObjectFactory::goodJetMaximalFractionOfEnergyIntheHottestHPDReadout = 0.98;
34
35	double const TestObjectFactory::goodMuonMinimalPt = 15.;
36	double const TestObjectFactory::goodMuonMaximalAbsoluteEta = 2.5;
37	double const TestObjectFactory::isolatedMuonMaximalRelativeIsolation = 0.2;
38
39	TestObjectFactory::TestObjectFactory() {
40
41	}
42
43	TestObjectFactory::~TestObjectFactory() {
44	}
45
46	VertexPointer TestObjectFactory::goodVertex() {
47	VertexPointer pv = VertexPointer(new Vertex());
48
49	pv->setFake(false);
50	pv->setDegreesOfFreedom(TestObjectFactory::goodVertexMinimalNumberOfDegreesOfFreedom);
51	pv->setRho(TestObjectFactory::goodVertexMaximalAbsoluteRho * 0.9);
52	pv->setZPosition(TestObjectFactory::goodVertexMaximalAbsoluteZPosition);
53
54	assert(pv->isGood());
55
56	return pv;
57	}
58
59	VertexPointer TestObjectFactory::badFakeVertex() {
60	VertexPointer pv(TestObjectFactory::goodVertex());
61
62	pv->setFake(true);
63
64	assert(pv->isGood() == false);
65
66	return pv;
67	}
68
69	VertexPointer TestObjectFactory::badNDOFVertex() {
70	VertexPointer pv(TestObjectFactory::goodVertex());
71
72	pv->setDegreesOfFreedom(TestObjectFactory::goodVertexMinimalNumberOfDegreesOfFreedom - 1);
73
74	assert(pv->isGood() == false);
75
76	return pv;
77	}
78
79	VertexPointer TestObjectFactory::badRhoVertex() {
80	VertexPointer pv(TestObjectFactory::goodVertex());
81
82	pv->setRho(TestObjectFactory::goodVertexMaximalAbsoluteRho * 1.1);
83
84	assert(pv->isGood() == false);
85
86	return pv;
87	}
88
89	VertexPointer TestObjectFactory::badZPositionVertex() {
90	VertexPointer pv(TestObjectFactory::goodVertex());
91
92	pv->setZPosition(TestObjectFactory::goodVertexMaximalAbsoluteZPosition * 1.1);
93
94	assert(pv->isGood() == false);
95
96	return pv;
97	}
98
99	ElectronPointer TestObjectFactory::goodCaloElectron() {
100	ElectronPointer electron = ElectronPointer(new Electron(100., 99., 13., 5.));
101	electron->setUsedAlgorithm(ElectronAlgorithm::Calo);
102	electron->setSuperClusterEta(0);
103	electron->setD0_wrtBeamSpot(0);
104	VertexPointer pv = TestObjectFactory::goodVertex();
105	electron->setZDistanceToPrimaryVertex(0);
106
107	electron->setDEtaIn(0);
108	electron->setDPhiIn(0);
109	electron->setHadOverEm(0);
110	electron->setSigmaIEtaIEta(0);
111
112	electron->setNumberOfMissingInnerLayerHits(0);
113	electron->setDCotThetaToNextTrack(0.5);
114	electron->setDistToNextTrack(0.5);
115	if (electron->isGood() == false) {
116	cout << "Et " << electron->et() << endl;
117	cout << "Eta " << electron->eta() << endl;
118	cout << "VBTF 70 " << electron->VBTF_W70_ElectronID() << endl;
119	cout << "d0 " << electron->d0_wrtBeamSpot() << endl;
120	cout << "Et " << electron->et() << endl;
121	}
122	assert(electron->isGood());
123	assert(electron->isFromConversion() == false);
124	assert(electron->isIsolated() == false);
125	return electron;
126	}
127
128	ElectronPointer TestObjectFactory::goodIsolatedElectron() {
129	ElectronPointer electron = TestObjectFactory::goodCaloElectron();
130	electron->setTrackerIsolation(0.4);
131	electron->setEcalIsolation(0.3);
132	electron->setHcalIsolation(0.5);
133
134	assert(electron->isIsolated());
135	assert(electron->isGood());
136	assert(electron->isFromConversion() == false);
137	assert(electron->isTaggedAsConversion(0.02,0.02) == false);
138	return electron;
139	}
140
141	ElectronPointer TestObjectFactory::goodIsolatedElectron2() {
142	ElectronPointer electron = TestObjectFactory::goodIsolatedElectron();
143	ElectronPointer electron2 = TestObjectFactory::goodIsolatedElectron();
144	FourVector vec = electron->getFourVector();
145	vec.SetPx(vec.Px() - 20);
146	vec.SetPy(-vec.Py());
147	vec.SetPz(-vec.Pz());
148	electron2->setFourVector(vec);
149	//Z mass requirement
150	assert(electron->invariantMass(electron2) > 80);
151	assert(electron->invariantMass(electron2) < 100);
152	assert(electron2->isIsolated());
153	assert(electron2->isGood());
154	return electron2;
155	}
156
157	ElectronPointer TestObjectFactory::badEtElectron() {
158	ElectronPointer badEtElectron(new Electron(20., 10., 0., 5.));
159	badEtElectron->setD0(0.01);
160	badEtElectron->setSuperClusterEta(1);
161
162	assert(fabs(badEtElectron->eta()) < TestObjectFactory::goodElectronMaximalAbsoluteEta);
163	assert(fabs(badEtElectron->d0()) < TestObjectFactory::goodElectronMaximalDistanceFromInteractionPoint);
164	//and fails the selected
165	assert(badEtElectron->et() < TestObjectFactory::goodElectronMinimalEt);
166	return badEtElectron;
167	}
168
169	ElectronPointer TestObjectFactory::badEtaElectron() {
170	ElectronPointer badEtaElectron(new Electron(400., 50., 50., 380));
171	badEtaElectron->setD0(0.01);
172	badEtaElectron->setSuperClusterEta(1);
173
174	assert(fabs(badEtaElectron->eta()) > TestObjectFactory::goodElectronMaximalAbsoluteEta);
175	assert(fabs(badEtaElectron->d0()) < TestObjectFactory::goodElectronMaximalDistanceFromInteractionPoint);
176	assert(badEtaElectron->et() > TestObjectFactory::goodElectronMinimalEt);
177
178	return badEtaElectron;
179	}
180
181	ElectronPointer TestObjectFactory::badInCrackElectron() {
182	ElectronPointer badInCrackElectron(TestObjectFactory::goodCaloElectron());
183	badInCrackElectron->setSuperClusterEta(1.5);
184
185	assert(badInCrackElectron->isInCrack());
186
187	return badInCrackElectron;
188	}
189
190	ElectronPointer TestObjectFactory::badD0Electron() {
191	ElectronPointer badD0Electron(TestObjectFactory::goodCaloElectron());
192	badD0Electron->setD0_wrtBeamSpot(300.);
193	badD0Electron->setD0(300.);
194
195	assert(fabs(badD0Electron->d0()) > goodElectronMaximalDistanceFromInteractionPoint);
196	assert(fabs(badD0Electron->d0_wrtBeamSpot()) > goodElectronMaximalDistanceFromInteractionPoint);
197
198	return badD0Electron;
199	}
200
201	ElectronPointer TestObjectFactory::electronWithMissingInnerLayerHit() {
202	ElectronPointer electronWithMissingInnerLayerHit(TestObjectFactory::goodCaloElectron());
203	electronWithMissingInnerLayerHit->setNumberOfMissingInnerLayerHits(1);
204
205	assert(electronWithMissingInnerLayerHit->innerLayerMissingHits() > MaximalNumberOfMissingInnerLayerHitsBeforeCalledConversion);
206	return electronWithMissingInnerLayerHit;
207
208	}
209
210	ElectronPointer TestObjectFactory::electronWithMatchingPartnerTrack() {
211	ElectronPointer electronWithMatchingPartnerTrack(TestObjectFactory::goodCaloElectron());
212	electronWithMatchingPartnerTrack->setDCotThetaToNextTrack(0.1);
213	electronWithMatchingPartnerTrack->setDistToNextTrack(0.01);
214
215	assert(electronWithMatchingPartnerTrack->distToClosestTrack() < TestObjectFactory::MinimalDistanceToNextTrackBeforeCalledConversion);
216	assert(electronWithMatchingPartnerTrack->dCotThetaToClosestTrack() < TestObjectFactory::MinimalDCotToNextTrackBeforeCalledConversion);
217
218	return electronWithMatchingPartnerTrack;
219	}
220
221	ElectronPointer TestObjectFactory::goodLooseElectron() {
222	ElectronPointer looseElectron(new Electron(100., 79., -13., -5.));
223	looseElectron->setSigmaIEtaIEta(0.009);
224	looseElectron->setDPhiIn(0.7);
225	looseElectron->setDEtaIn(0.006);
226	looseElectron->setHadOverEm(0.14);
227	looseElectron->setSuperClusterEta(1);
228	looseElectron->setEcalIsolation(0);
229	looseElectron->setTrackerIsolation(0);
230	looseElectron->setHcalIsolation(0);
231
232	looseElectron->setNumberOfMissingInnerLayerHits(0);
233	looseElectron->setD0(0);
234	looseElectron->setSuperClusterEta(0);
235
236	assert(looseElectron->isGood() == false);
237	assert(looseElectron->isLoose());
238
239	return looseElectron;
240	}
241
242	ElectronPointer TestObjectFactory::badLooseElectronNoID() {
243	ElectronPointer badLooseElectronNoID(goodLooseElectron());
244	badLooseElectronNoID->setHcalIsolation(0.5);
245	badLooseElectronNoID->setEcalIsolation(0.3);
246	badLooseElectronNoID->setTrackerIsolation(0.4);
247	badLooseElectronNoID->setSigmaIEtaIEta(0.009 + 2);
248
249	assert(badLooseElectronNoID->VBTF_W95_ElectronID() == false);
250
251	return badLooseElectronNoID;
252	}
253
254	ElectronPointer TestObjectFactory::badElectronNoID() {
255	ElectronPointer badElectronNoID(TestObjectFactory::goodCaloElectron());
256	badElectronNoID->setHcalIsolation(0.5);
257	badElectronNoID->setEcalIsolation(0.3);
258	badElectronNoID->setTrackerIsolation(0.4);
259	badElectronNoID->setSigmaIEtaIEta(0.009 + 2);
260
261	assert(badElectronNoID->VBTF_W70_ElectronID() == false);
262
263	return badElectronNoID;
264	}
265
266	JetPointer TestObjectFactory::goodCaloJet() {
267	JetPointer goodJet(new Jet(290., 200., 200., 0.));
268	goodJet->setEMF(0.1);
269	goodJet->setN90Hits(2.);
270	goodJet->setFHPD(0.5);
271
272	assert(goodJet->isGood());
273
274	return goodJet;
275	}
276
277	JetPointer TestObjectFactory::badEMFCaloJet() {
278	JetPointer badEMFJet(TestObjectFactory::goodCaloJet());
279
280	badEMFJet->setEMF(goodJetMinimalElectromagneticFraction - 0.1);
281
282	assert(badEMFJet->isGood() == false);
283
284	return badEMFJet;
285	}
286
287	JetPointer TestObjectFactory::badN90CaloJet() {
288	JetPointer badN90Jet(TestObjectFactory::goodCaloJet());
289
290	badN90Jet->setN90Hits(TestObjectFactory::goodJetMinimalNumberOfRecHitsContaining90PercentOfTheJetEnergy - 1);
291
292	assert(badN90Jet->isGood() == false);
293
294	return badN90Jet;
295	}
296
297	JetPointer TestObjectFactory::badfHPDCaloJet() {
298	JetPointer badfHPDJet(TestObjectFactory::goodCaloJet());
299
300	badfHPDJet->setFHPD(TestObjectFactory::goodJetMaximalFractionOfEnergyIntheHottestHPDReadout + 0.01);
301
302	assert(badfHPDJet->isGood() == false);
303
304	return badfHPDJet;
305	}
306
307	JetPointer TestObjectFactory::badEtCaloJet() {
308	JetPointer badEtJet(TestObjectFactory::goodCaloJet());
309
310	badEtJet->setFourVector(FourVector(20., 20., 0., 20));
311
312	assert(badEtJet->isGood() == false);
313
314	return badEtJet;
315	}
316
317	JetPointer TestObjectFactory::badEtaCaloJet() {
318	JetPointer badEtJet(TestObjectFactory::goodCaloJet());
319
320	badEtJet->setFourVector(FourVector(200., 0., 2000., 2900.));
321
322	assert(badEtJet->isGood() == false);
323
324	return badEtJet;
325	}
326
327	JetPointer TestObjectFactory::goodCaloBJetSSVHEM() {
328	JetPointer goodBJet(TestObjectFactory::goodCaloJet());
329
330	goodBJet->setDiscriminatorForBtagType(1.7 + 0.1, BtagAlgorithm::SimpleSecondaryVertexHighEffBTag);
331
332	assert(goodBJet->isGood());
333	assert(goodBJet->isBJet(BtagAlgorithm::SimpleSecondaryVertexHighEffBTag));
334
335	return goodBJet;
336	}
337
338	/**
339	* This depends on TestObjectFactory::goodCaloElectron()!!
340	*/
341	JetPointer TestObjectFactory::goodCaloJetCloseToCaloElectron() {
342	JetPointer goodJet(TestObjectFactory::goodCaloJet());
343
344	goodJet->setFourVector(FourVector(98., 13., 5., 100.));
345
346	return goodJet;
347	}
348
349	MuonPointer TestObjectFactory::goodIsolatedMuon() {
350	MuonPointer goodIsolatedMuon(new Muon(100., 99., 13., 5.));
351
352	goodIsolatedMuon->makeGlobal(true);
353	goodIsolatedMuon->setEcalIsolation(1);
354	goodIsolatedMuon->setHcalIsolation(1);
355	goodIsolatedMuon->setTrackerIsolation(1);
356
357	assert(goodIsolatedMuon->isGood());
358	assert(goodIsolatedMuon->isIsolated());
359
360	return goodIsolatedMuon;
361	}
362
363	MuonPointer TestObjectFactory::goodNonIsolatedMuon() {
364	MuonPointer goodNonIsoMuon(TestObjectFactory::goodIsolatedMuon());
365
366	goodNonIsoMuon->setEcalIsolation(200);
367	goodNonIsoMuon->setHcalIsolation(200);
368	goodNonIsoMuon->setTrackerIsolation(200);
369
370	assert(goodNonIsoMuon->isGood());
371	assert(goodNonIsoMuon->isIsolated() == false);
372
373	return goodNonIsoMuon;
374	}
375
376	MuonPointer TestObjectFactory::badNonGlobalMuon() {
377	MuonPointer nonGlobalMuon(TestObjectFactory::goodIsolatedMuon());
378
379	nonGlobalMuon->makeGlobal(false);
380
381	assert(nonGlobalMuon->isGood() == false);
382
383	return nonGlobalMuon;
384	}
385
386	MuonPointer TestObjectFactory::badPtMuon() {
387	MuonPointer badMuonLowPt(new Muon(5., 4., 1., 1.));
388
389	assert(badMuonLowPt->isGood() == false);
390
391	return badMuonLowPt;
392	}
393
394	MuonPointer TestObjectFactory::badEtaMuon() {
395	MuonPointer badEtaMu(new Muon(450., 50., 50., 444.));
396
397	assert(badEtaMu->isGood() == false);
398
399	return badEtaMu;
400	}
401
402	METPointer TestObjectFactory::goodMET() {
403	METPointer goodMET(new MET(40, 30));
404
405	assert(goodMET->isGood());
406
407	return goodMET;
408	}
409
410	METPointer TestObjectFactory::badMET() {
411	METPointer badMissingET(new MET(4, 3));
412
413	assert(badMissingET->isGood() == false);
414
415	return badMissingET;
416	}
417