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
Committed:	Thu Dec 1 16:28:47 2011 UTC (13 years, 5 months ago) by dhidas
Branch point for:	dhidas, MAIN
Log Message:	Initial revision
#	User	Rev	Content
1	dhidas	1.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