Tools/interface/ToplikeCandidate.h

#ifndef TOPLIKECANDIDATE_H_
#define TOPLIKECANDIDATE_H_


#include <map>

#include "RecoObjects/MCParticle.h"
#include "TopPairEventCandidate.h"

// using namespace BAT;
using namespace std;

namespace BAT {


namespace ToplikeSelectionSteps {  // Note the name space!
enum Step {     // Any new constant must be added to selStepArr below.
// Note this order not important.  See selection arrays below.
    FilterOutScraping,
    GoodPrimaryvertex,
    HighLevelTrigger,
    OneIsolatedElectron,
    OneIsolatedMuon,
    LooseMuonVeto,
    LooseElectronVeto,
    TightMuonVeto,
    TightElectronVeto,
    ConversionRejection,
    ConversionFinder,
    MissingTransverseEnergy,
    HT700GeV,
    AtLeastOneGoodJet,
    AtLeastTwoGoodJets,
    AtLeastThreeGoodJets,
    AtLeastFourGoodJets,
    AtLeastFiveGoodJets,
    FortyfiveGeVElectron,
    AtLeastOneBtag,
    AtLeastTwoBtags
};

const std::string StringSteps[] = {
        "Scraping Filter",
        "Good primary vertex",
        "High Level Trigger",
        "Exactly one isolated electron",
        "Exactly one isolated muon",
        "Loose muon veto",
        "Loose electron veto",
        "Tight muon veto",
        "Tight electron veto",
        "Conversion veto (missing hits)",
        "Conversion finder (partner track)",
        "MpT $>$ 20 GeV",
        "HT (sum pT) $>$ 700 GeV",
        "$>=$ 1 jets $>$180 GeV",
        "$>=$ 2 jets $>$90 GeV",
        "$>=$ 3 jets",
        "$>=$ 4 jets",
        "$>=$ 5 jets",
        "$>$45 GeV electron pT",
        "$>=$1 SSV b-tag",
        "$>=$2 SSV b-tags"
};
}

typedef struct {
        ToplikeSelectionSteps::Step key;
        TTbarEPlusJetsSelection::Step value;
} selPair;
        
const selPair selStepArr[] = {
        {ToplikeSelectionSteps::FilterOutScraping, TTbarEPlusJetsSelection::FilterOutScraping}, 
        {ToplikeSelectionSteps::HighLevelTrigger, TTbarEPlusJetsSelection::HighLevelTrigger},   
        {ToplikeSelectionSteps::GoodPrimaryvertex, TTbarEPlusJetsSelection::GoodPrimaryvertex}, 
        {ToplikeSelectionSteps::OneIsolatedElectron, TTbarEPlusJetsSelection::OneIsolatedElectron},     
        {ToplikeSelectionSteps::LooseMuonVeto, TTbarEPlusJetsSelection::LooseMuonVeto}, 
        {ToplikeSelectionSteps::ConversionRejection, TTbarEPlusJetsSelection::ConversionRejection},     
        {ToplikeSelectionSteps::ConversionFinder, TTbarEPlusJetsSelection::ConversionFinder},   
        {ToplikeSelectionSteps::AtLeastOneGoodJet, TTbarEPlusJetsSelection::AtLeastOneGoodJets},        
        {ToplikeSelectionSteps::AtLeastTwoGoodJets, TTbarEPlusJetsSelection::AtLeastTwoGoodJets},       
        {ToplikeSelectionSteps::AtLeastThreeGoodJets, TTbarEPlusJetsSelection::AtLeastThreeGoodJets},   
        {ToplikeSelectionSteps::AtLeastFourGoodJets, TTbarEPlusJetsSelection::AtLeastFourGoodJets},     
        {ToplikeSelectionSteps::AtLeastOneBtag, TTbarEPlusJetsSelection::AtLeastOneBtag},       
        {ToplikeSelectionSteps::AtLeastTwoBtags, TTbarEPlusJetsSelection::AtLeastTwoBtags},     
        {ToplikeSelectionSteps::MissingTransverseEnergy, TTbarEPlusJetsSelection::MissingTransverseEnergy}
};


const ToplikeSelectionSteps::Step toplikeElectronSelection[] = {
        ToplikeSelectionSteps::HighLevelTrigger,
        ToplikeSelectionSteps::OneIsolatedElectron,
        ToplikeSelectionSteps::TightMuonVeto,
        ToplikeSelectionSteps::ConversionRejection,
        ToplikeSelectionSteps::ConversionFinder,
        ToplikeSelectionSteps::MissingTransverseEnergy,
        ToplikeSelectionSteps::HT700GeV,
        ToplikeSelectionSteps::AtLeastOneGoodJet,
        ToplikeSelectionSteps::AtLeastTwoGoodJets,
        ToplikeSelectionSteps::AtLeastOneBtag,
        ToplikeSelectionSteps::AtLeastThreeGoodJets,
        ToplikeSelectionSteps::AtLeastFourGoodJets,
        ToplikeSelectionSteps::AtLeastFiveGoodJets
  // ToplikeSelectionSteps::AtLeastTwoBtags
};

const unsigned int toplikeElectronSelSize =
sizeof(toplikeElectronSelection)/sizeof(ToplikeSelectionSteps::AtLeastOneGoodJet);

const ToplikeSelectionSteps::Step toplikeMuonSelection[] = {
        ToplikeSelectionSteps::HighLevelTrigger,
        ToplikeSelectionSteps::OneIsolatedMuon,
        ToplikeSelectionSteps::TightElectronVeto,
        ToplikeSelectionSteps::MissingTransverseEnergy,
        ToplikeSelectionSteps::HT700GeV,
        ToplikeSelectionSteps::AtLeastOneGoodJet,
        ToplikeSelectionSteps::AtLeastTwoGoodJets,
        ToplikeSelectionSteps::AtLeastOneBtag,
        ToplikeSelectionSteps::AtLeastThreeGoodJets,
        ToplikeSelectionSteps::AtLeastFourGoodJets,
        ToplikeSelectionSteps::AtLeastFiveGoodJets
  // ToplikeSelectionSteps::AtLeastTwoBtags
};

const unsigned int toplikeMuonSelSize =
        sizeof(toplikeMuonSelection)/sizeof(ToplikeSelectionSteps::AtLeastOneGoodJet);


typedef struct {
        float deltaR;
        bool leptonic, hadronic;
} topTruth;

typedef struct {
        float deltaR;
        int gpInd;
        MCParticlePointer ptr;
} mcObj;


typedef std::vector< mcObj > mcList;


class ToplikeCandidate : public TopPairEventCandidate {

protected:
    // ElectronPointer electronFromW;
    // JetPointer leptonicBJet, hadronicBJet, jet1FromW, jet2FromW;
    JetPointer jet3FromW, jet4FromW;
    ParticlePointer hadronicWtPrime, tPrime;
    // ParticlePointer neutrino1, neutrino2, leptonicW1, leptonicW2, hadronicW,
    // leptonicTop1, leptonicTop2, hadronicTop, ttbarResonance;
    // unsigned short selectedNeutrino, currentSelectedNeutrino, hadronicBIndex,
    // leptonicBIndex, jet1FromWIndex, jet2FromWIndex;
    unsigned short jet3FromWIndex, jet4FromWIndex;
                double ptTprimeSystem, htSystem;
    bool doneReconstructiontop;
                mcList getMCList(const Particle *const recoObject) const;
                mcList getMCListForJets(const Jet *const recoObject) const;
                bool chkBW(const int ind1, const int ind2, const int ind3) const;
    bool chkIfChild(int gpInd, int motherGpInd) const;
    int chkMCMatch(const Particle *const recoObject, int motherInd, 
        const int pdgId, int antiId = 0) const;
    int chkForQuark(const JetPointer recoObject, const int motherInd,
        const int badInd = -1) const;
    int getNumMCMatchesForTop(const ParticlePointer &recoTop, 
        bool hadronic = true) const;
    int getNumMCPermutsForTop(const ParticlePointer &recoTop, 
                        bool hadronic = true) const;
                // int lTopDauMatching(const mcObj &topTru) const;
                // int hTopDauMatching(const mcObj &topTru) const;
    int strictHTopMatching(const mcObj &topTru) const;
    int strictLTopMatching(const mcObj &topTru) const;
    
public:
    ToplikeCandidate();
    ToplikeCandidate(const Event& event);
    virtual ~ToplikeCandidate();

    virtual bool isTopReconstructed(void) const {
                        return doneReconstructiontop; 
    }

    /*
    const JetPointer getJet3FromHadronicW2() const;
    const JetPointer getJet4FromHadronicW2() const;
    const ParticlePointer getHadronicW2() const;
    const ParticlePointer getTprimeResonance() const;
    */

    void recoTprimeUsingChi2(ElectronPointer electron);
                virtual void recoBestSingleTop(LeptonPointer lepton);
                double TPrimeHTSystem() const;
                double PtTPrimeSystem() const;

    // Overload the following
                // virtual const ParticlePointer getResonance() const;
                bool hasAtLeastFiveGoodJets() const;
                double tpmass() const;
    virtual double getGlobalChi2() const;
                virtual double getLeptonicChi2(double topMass, double unused) const;
                virtual double getHadronicChi2() const;
    double getWChi2() const;
                double sumPt() const;
                double PtTtbarSystem() const;
                double PtTtbarSystem(unsigned short neutrinoSolution) const;
                virtual double getLoneHadChi2() const;
                topTruth getMCMatches(const ParticlePointer &recoObject) const;
    int getNumMCMatchesHTop() const;
    int getNumMCMatchesLTop() const;
                int getNumCorrectIDLTop() const;
                int getNumCorrectIDHTop() const;
                int goodLTopMatching() const;
                int goodHTopMatching() const;
                int getTausInJets() const;
                int numTaus() const;
                int missRecoJetsForGenJets() const;
                int missGenJetsForRecoJets() const;
};


class TopNoMassConstraint : public ToplikeCandidate {
public:
        TopNoMassConstraint();
        TopNoMassConstraint(const Event& event);
        virtual ~TopNoMassConstraint();
        
        virtual double getLoneHadChi2() const;
  virtual double getLepBAngle() const;
};


class TopPlusXCandidates : public ToplikeCandidate {
public:
        
        static const JetPointer nulljet;
        
        TopPlusXCandidates();
        TopPlusXCandidates(const Event& event);
        virtual ~TopPlusXCandidates();
        
        virtual void recoBestLeptoTop(LeptonPointer lepton,
                const JetPointer jet = nulljet, const JetPointer wJet1 = nulljet,
                const JetPointer wJet2 = nulljet);
        virtual void recoHadronicTop(LeptonPointer lepton,
                const JetPointer jet = nulljet);
        virtual void findDJet(const JetPointer topJet = nulljet);
        virtual bool passesSelectionStep(enum
                ToplikeSelectionSteps::Step step) const;
        virtual bool passesSelectionStepUpTo(unsigned int step,
                const ToplikeSelectionSteps::Step steps[]) const;
        virtual bool passesFullEPlusJetSelection() const;
        virtual bool passesFullEPlusJetSelectionKK() const;
        virtual bool passesFullMuPlusJetSelection() const;
        virtual bool passesMETCut() const;
        virtual bool passesHTCut() const;
        virtual bool passesExtraElectronCut() const;
        virtual bool hasOnlyOneGoodIsolatedMuon() const;
        virtual bool hasNoIsolatedElectron() const;
        virtual bool hasNoGoodIsolatedElectron() const;
        virtual bool hasNoGoodIsolatedMuon() const;
        virtual bool hasAtLeastOneGoodJet() const;
        virtual bool hasAtLeastTwoGoodJets() const;

        virtual double jetsHTNoTop(unsigned int numJets = 3) const;
        virtual double ST() const;
        virtual double getTopMetAngle() const;
        virtual JetPointer leadnontopjet() const;
        virtual double mass2jets(unsigned int jet1, unsigned int jet2) const;
        virtual double mass4jets() const;

        // The templates below are no longer necessary because there is now a
        // LeptonPointer, but they still work, so leave them as-is.
        
        // Template functions must be defined here to be instantiated in other files.
        template <class PartPtr> double transMass4j(const PartPtr leptonPtr) const {
                double px = leptonPtr->px() + met->px();
                double py = leptonPtr->py() + met->py();
                double pz = 0.0;
                double et =  leptonPtr->et() + met->et();
                for (unsigned short jetIndex = 0; jetIndex < 4 && jetIndex < goodJets.size(); ++jetIndex) {
                        px += goodJets.at(jetIndex)->px();
                        py += goodJets.at(jetIndex)->py();
                        et += goodJets.at(jetIndex)->et();
                }
                Particle mt(et, px, py, pz);
                return (mt.mass());
        }

        template <class PartPtr> double transMass2j(const PartPtr leptonPtr) const {
                double px = leptonPtr->px() + met->px();
                double py = leptonPtr->py() + met->py();
                double pz = 0.0;
                double et =  leptonPtr->et() + met->et();
                if (goodBJets.size() > 0) {
                        px += goodBJets.front()->px();
                        py += goodBJets.front()->py();
                        et += goodBJets.front()->et();
                }
                for (unsigned short jetIndex = 0;  jetIndex < 2 && jetIndex < goodJets.size(); ++jetIndex) {
                        if (goodBJets.size() <= 0 || goodJets.at(jetIndex) !=  goodBJets.front()) {
                                px += goodJets.at(jetIndex)->px();
                                py += goodJets.at(jetIndex)->py();
                                et += goodJets.at(jetIndex)->et();
                                jetIndex = 2; // Terminate loop.
                        }
                }
                Particle mt(et, px, py, pz);
                return (mt.mass());
        }


        template <class PartPtr> const ParticlePointer transMasslm1b(const PartPtr leptonPtr) const {
                double px = leptonPtr->px() + met->px();
                double py = leptonPtr->py() + met->py();
                double pz = 0.0;
                double et =  leptonPtr->et() + met->et();
                if (goodBJets.size() > 0) {
                        px += goodBJets.front()->px();
                        py += goodBJets.front()->py();
                        et += goodBJets.front()->et();
                }
                return (ParticlePointer(new Particle(et, px, py, pz)));
        }


        template <class PartPtr> const ParticlePointer massl1b(const PartPtr leptonPtr) const {
                double px = leptonPtr->px();
                double py = leptonPtr->py();
                double pz = 0.0;
                double et =  leptonPtr->et();
                if (goodBJets.size() > 0) {
                        px += goodBJets.front()->px();
                        py += goodBJets.front()->py();
                        et += goodBJets.front()->et();
                }
                return (ParticlePointer(new Particle(et, px, py, pz)));
        }


        template <class PartPtr> double deltaPhiTops(const PartPtr leptonPtr) const {
                double px = 0.0, py = 0.0, pz = 0.0, et = 0.0;
                for (unsigned short jetIndex = 1; jetIndex < 4 && jetIndex < goodJets.size(); ++jetIndex) {
                        px += goodJets.at(jetIndex)->px();
                        py += goodJets.at(jetIndex)->py();
                        et += goodJets.at(jetIndex)->et();
                }
                ParticlePointer mt = ParticlePointer(new Particle(et, px, py, pz));
                return (transMasslm1b(leptonPtr)->deltaPhi(mt));
        }


        template <class PartPtr> double deltaPhiLepJet(const PartPtr leptonPtr) const {
                if (goodJets.size() > 0)
                        return (leptonPtr->deltaPhi(goodJets.front()));
                return (0.0);
        }
        

        JetPointer dJetFromWp;
        short dJetFromWpIndex;
};


class TwoNonResTops : public TopPlusXCandidates {
public:
        TwoNonResTops();
        TwoNonResTops(const Event& event);
        virtual ~TwoNonResTops();
        
        void recoNonResTops(LeptonPointer lepton);
        void recoNonResTopsWdjet(LeptonPointer lepton);
        void recoWpFrom1Top(LeptonPointer lepton);
        virtual double getGlobalChi2() const;
        virtual const JetPointer getLtNonTopJet() const;
        virtual const ParticlePointer getWprime() const;
        virtual const ParticlePointer getBtBWprime() const;
        virtual const ParticlePointer getNegWprime() const;
        virtual const ParticlePointer getNegWprimeBad() const;
        virtual double getHadTopDAngle() const;
        virtual void getTrueWpChain();
        virtual MCParticlePointer getWpTru() const;
        virtual MCParticlePointer getWpTopTru() const;
        virtual MCParticlePointer getSpecTop() const;
        virtual MCParticlePointer getWpTopBTru() const;
        virtual MCParticlePointer getSpecTopB() const;
        virtual MCParticlePointer getWpDDauTru() const;
  virtual double getTotalChi2DJ(unsigned short neutrinoSolution) const;

        template <class PartPtr> double deltaPhiLepDJet(const PartPtr leptonPtr) const {
                if (goodJets.size() > 4)
                        return (leptonPtr->deltaPhi(getLtNonTopJet()));
                return (0.0);
        }
        
        ParticlePointer wpFrom1Top, wpBadFrom1Top;

protected:
        MCParticlePointer wpTru, wpTopTru, specTopTru, wpDDauTru;
        MCParticlePointer wpTopBTru, specTopBTru;
        bool wpGenParticlesSet;
        ParticlePointer topFromWp;
};


class LeptoTopNoMassConstraint : public TopNoMassConstraint {
public:
        LeptoTopNoMassConstraint();
        LeptoTopNoMassConstraint(const Event& event);
        virtual ~LeptoTopNoMassConstraint();
        
        // virtual bool passesFullEPlusJetSelection() const;
        virtual void inspectReconstructedEvent() const;

};

}

#endif /* TOPLIKECANDIDATE_H_ */
Revision:	1.1.1.1 (vendor branch)
Committed:	Thu Dec 1 16:28:48 2011 UTC (13 years, 5 months ago) by dhidas
Content type:	text/plain
Branch:	dhidas
CVS Tags:	START
Changes since 1.1:	+0 -0 lines
Log Message:	osu copy modified
#	User	Rev	Content
1	dhidas	1.1	#ifndef TOPLIKECANDIDATE_H_
2			#define TOPLIKECANDIDATE_H_
3
4
5			#include <map>
6
7			#include "RecoObjects/MCParticle.h"
8			#include "TopPairEventCandidate.h"
9
10			// using namespace BAT;
11			using namespace std;
12
13			namespace BAT {
14
15
16			namespace ToplikeSelectionSteps { // Note the name space!
17			enum Step { // Any new constant must be added to selStepArr below.
18			// Note this order not important. See selection arrays below.
19			FilterOutScraping,
20			GoodPrimaryvertex,
21			HighLevelTrigger,
22			OneIsolatedElectron,
23			OneIsolatedMuon,
24			LooseMuonVeto,
25			LooseElectronVeto,
26			TightMuonVeto,
27			TightElectronVeto,
28			ConversionRejection,
29			ConversionFinder,
30			MissingTransverseEnergy,
31			HT700GeV,
32			AtLeastOneGoodJet,
33			AtLeastTwoGoodJets,
34			AtLeastThreeGoodJets,
35			AtLeastFourGoodJets,
36			AtLeastFiveGoodJets,
37			FortyfiveGeVElectron,
38			AtLeastOneBtag,
39			AtLeastTwoBtags
40			};
41
42			const std::string StringSteps[] = {
43			"Scraping Filter",
44			"Good primary vertex",
45			"High Level Trigger",
46			"Exactly one isolated electron",
47			"Exactly one isolated muon",
48			"Loose muon veto",
49			"Loose electron veto",
50			"Tight muon veto",
51			"Tight electron veto",
52			"Conversion veto (missing hits)",
53			"Conversion finder (partner track)",
54			"MpT $>$ 20 GeV",
55			"HT (sum pT) $>$ 700 GeV",
56			"$>=$ 1 jets $>$180 GeV",
57			"$>=$ 2 jets $>$90 GeV",
58			"$>=$ 3 jets",
59			"$>=$ 4 jets",
60			"$>=$ 5 jets",
61			"$>$45 GeV electron pT",
62			"$>=$1 SSV b-tag",
63			"$>=$2 SSV b-tags"
64			};
65			}
66
67			typedef struct {
68			ToplikeSelectionSteps::Step key;
69			TTbarEPlusJetsSelection::Step value;
70			} selPair;
71
72			const selPair selStepArr[] = {
73			{ToplikeSelectionSteps::FilterOutScraping, TTbarEPlusJetsSelection::FilterOutScraping},
74			{ToplikeSelectionSteps::HighLevelTrigger, TTbarEPlusJetsSelection::HighLevelTrigger},
75			{ToplikeSelectionSteps::GoodPrimaryvertex, TTbarEPlusJetsSelection::GoodPrimaryvertex},
76			{ToplikeSelectionSteps::OneIsolatedElectron, TTbarEPlusJetsSelection::OneIsolatedElectron},
77			{ToplikeSelectionSteps::LooseMuonVeto, TTbarEPlusJetsSelection::LooseMuonVeto},
78			{ToplikeSelectionSteps::ConversionRejection, TTbarEPlusJetsSelection::ConversionRejection},
79			{ToplikeSelectionSteps::ConversionFinder, TTbarEPlusJetsSelection::ConversionFinder},
80			{ToplikeSelectionSteps::AtLeastOneGoodJet, TTbarEPlusJetsSelection::AtLeastOneGoodJets},
81			{ToplikeSelectionSteps::AtLeastTwoGoodJets, TTbarEPlusJetsSelection::AtLeastTwoGoodJets},
82			{ToplikeSelectionSteps::AtLeastThreeGoodJets, TTbarEPlusJetsSelection::AtLeastThreeGoodJets},
83			{ToplikeSelectionSteps::AtLeastFourGoodJets, TTbarEPlusJetsSelection::AtLeastFourGoodJets},
84			{ToplikeSelectionSteps::AtLeastOneBtag, TTbarEPlusJetsSelection::AtLeastOneBtag},
85			{ToplikeSelectionSteps::AtLeastTwoBtags, TTbarEPlusJetsSelection::AtLeastTwoBtags},
86			{ToplikeSelectionSteps::MissingTransverseEnergy, TTbarEPlusJetsSelection::MissingTransverseEnergy}
87			};
88
89
90			const ToplikeSelectionSteps::Step toplikeElectronSelection[] = {
91			ToplikeSelectionSteps::HighLevelTrigger,
92			ToplikeSelectionSteps::OneIsolatedElectron,
93			ToplikeSelectionSteps::TightMuonVeto,
94			ToplikeSelectionSteps::ConversionRejection,
95			ToplikeSelectionSteps::ConversionFinder,
96			ToplikeSelectionSteps::MissingTransverseEnergy,
97			ToplikeSelectionSteps::HT700GeV,
98			ToplikeSelectionSteps::AtLeastOneGoodJet,
99			ToplikeSelectionSteps::AtLeastTwoGoodJets,
100			ToplikeSelectionSteps::AtLeastOneBtag,
101			ToplikeSelectionSteps::AtLeastThreeGoodJets,
102			ToplikeSelectionSteps::AtLeastFourGoodJets,
103			ToplikeSelectionSteps::AtLeastFiveGoodJets
104			// ToplikeSelectionSteps::AtLeastTwoBtags
105			};
106
107			const unsigned int toplikeElectronSelSize =
108			sizeof(toplikeElectronSelection)/sizeof(ToplikeSelectionSteps::AtLeastOneGoodJet);
109
110			const ToplikeSelectionSteps::Step toplikeMuonSelection[] = {
111			ToplikeSelectionSteps::HighLevelTrigger,
112			ToplikeSelectionSteps::OneIsolatedMuon,
113			ToplikeSelectionSteps::TightElectronVeto,
114			ToplikeSelectionSteps::MissingTransverseEnergy,
115			ToplikeSelectionSteps::HT700GeV,
116			ToplikeSelectionSteps::AtLeastOneGoodJet,
117			ToplikeSelectionSteps::AtLeastTwoGoodJets,
118			ToplikeSelectionSteps::AtLeastOneBtag,
119			ToplikeSelectionSteps::AtLeastThreeGoodJets,
120			ToplikeSelectionSteps::AtLeastFourGoodJets,
121			ToplikeSelectionSteps::AtLeastFiveGoodJets
122			// ToplikeSelectionSteps::AtLeastTwoBtags
123			};
124
125			const unsigned int toplikeMuonSelSize =
126			sizeof(toplikeMuonSelection)/sizeof(ToplikeSelectionSteps::AtLeastOneGoodJet);
127
128
129			typedef struct {
130			float deltaR;
131			bool leptonic, hadronic;
132			} topTruth;
133
134			typedef struct {
135			float deltaR;
136			int gpInd;
137			MCParticlePointer ptr;
138			} mcObj;
139
140
141			typedef std::vector< mcObj > mcList;
142
143
144			class ToplikeCandidate : public TopPairEventCandidate {
145
146			protected:
147			// ElectronPointer electronFromW;
148			// JetPointer leptonicBJet, hadronicBJet, jet1FromW, jet2FromW;
149			JetPointer jet3FromW, jet4FromW;
150			ParticlePointer hadronicWtPrime, tPrime;
151			// ParticlePointer neutrino1, neutrino2, leptonicW1, leptonicW2, hadronicW,
152			// leptonicTop1, leptonicTop2, hadronicTop, ttbarResonance;
153			// unsigned short selectedNeutrino, currentSelectedNeutrino, hadronicBIndex,
154			// leptonicBIndex, jet1FromWIndex, jet2FromWIndex;
155			unsigned short jet3FromWIndex, jet4FromWIndex;
156			double ptTprimeSystem, htSystem;
157			bool doneReconstructiontop;
158			mcList getMCList(const Particle *const recoObject) const;
159			mcList getMCListForJets(const Jet *const recoObject) const;
160			bool chkBW(const int ind1, const int ind2, const int ind3) const;
161			bool chkIfChild(int gpInd, int motherGpInd) const;
162			int chkMCMatch(const Particle *const recoObject, int motherInd,
163			const int pdgId, int antiId = 0) const;
164			int chkForQuark(const JetPointer recoObject, const int motherInd,
165			const int badInd = -1) const;
166			int getNumMCMatchesForTop(const ParticlePointer &recoTop,
167			bool hadronic = true) const;
168			int getNumMCPermutsForTop(const ParticlePointer &recoTop,
169			bool hadronic = true) const;
170			// int lTopDauMatching(const mcObj &topTru) const;
171			// int hTopDauMatching(const mcObj &topTru) const;
172			int strictHTopMatching(const mcObj &topTru) const;
173			int strictLTopMatching(const mcObj &topTru) const;
174
175			public:
176			ToplikeCandidate();
177			ToplikeCandidate(const Event& event);
178			virtual ~ToplikeCandidate();
179
180			virtual bool isTopReconstructed(void) const {
181			return doneReconstructiontop;
182			}
183
184			/*
185			const JetPointer getJet3FromHadronicW2() const;
186			const JetPointer getJet4FromHadronicW2() const;
187			const ParticlePointer getHadronicW2() const;
188			const ParticlePointer getTprimeResonance() const;
189			*/
190
191			void recoTprimeUsingChi2(ElectronPointer electron);
192			virtual void recoBestSingleTop(LeptonPointer lepton);
193			double TPrimeHTSystem() const;
194			double PtTPrimeSystem() const;
195
196			// Overload the following
197			// virtual const ParticlePointer getResonance() const;
198			bool hasAtLeastFiveGoodJets() const;
199			double tpmass() const;
200			virtual double getGlobalChi2() const;
201			virtual double getLeptonicChi2(double topMass, double unused) const;
202			virtual double getHadronicChi2() const;
203			double getWChi2() const;
204			double sumPt() const;
205			double PtTtbarSystem() const;
206			double PtTtbarSystem(unsigned short neutrinoSolution) const;
207			virtual double getLoneHadChi2() const;
208			topTruth getMCMatches(const ParticlePointer &recoObject) const;
209			int getNumMCMatchesHTop() const;
210			int getNumMCMatchesLTop() const;
211			int getNumCorrectIDLTop() const;
212			int getNumCorrectIDHTop() const;
213			int goodLTopMatching() const;
214			int goodHTopMatching() const;
215			int getTausInJets() const;
216			int numTaus() const;
217			int missRecoJetsForGenJets() const;
218			int missGenJetsForRecoJets() const;
219			};
220
221
222			class TopNoMassConstraint : public ToplikeCandidate {
223			public:
224			TopNoMassConstraint();
225			TopNoMassConstraint(const Event& event);
226			virtual ~TopNoMassConstraint();
227
228			virtual double getLoneHadChi2() const;
229			virtual double getLepBAngle() const;
230			};
231
232
233			class TopPlusXCandidates : public ToplikeCandidate {
234			public:
235
236			static const JetPointer nulljet;
237
238			TopPlusXCandidates();
239			TopPlusXCandidates(const Event& event);
240			virtual ~TopPlusXCandidates();
241
242			virtual void recoBestLeptoTop(LeptonPointer lepton,
243			const JetPointer jet = nulljet, const JetPointer wJet1 = nulljet,
244			const JetPointer wJet2 = nulljet);
245			virtual void recoHadronicTop(LeptonPointer lepton,
246			const JetPointer jet = nulljet);
247			virtual void findDJet(const JetPointer topJet = nulljet);
248			virtual bool passesSelectionStep(enum
249			ToplikeSelectionSteps::Step step) const;
250			virtual bool passesSelectionStepUpTo(unsigned int step,
251			const ToplikeSelectionSteps::Step steps[]) const;
252			virtual bool passesFullEPlusJetSelection() const;
253			virtual bool passesFullEPlusJetSelectionKK() const;
254			virtual bool passesFullMuPlusJetSelection() const;
255			virtual bool passesMETCut() const;
256			virtual bool passesHTCut() const;
257			virtual bool passesExtraElectronCut() const;
258			virtual bool hasOnlyOneGoodIsolatedMuon() const;
259			virtual bool hasNoIsolatedElectron() const;
260			virtual bool hasNoGoodIsolatedElectron() const;
261			virtual bool hasNoGoodIsolatedMuon() const;
262			virtual bool hasAtLeastOneGoodJet() const;
263			virtual bool hasAtLeastTwoGoodJets() const;
264
265			virtual double jetsHTNoTop(unsigned int numJets = 3) const;
266			virtual double ST() const;
267			virtual double getTopMetAngle() const;
268			virtual JetPointer leadnontopjet() const;
269			virtual double mass2jets(unsigned int jet1, unsigned int jet2) const;
270			virtual double mass4jets() const;
271
272			// The templates below are no longer necessary because there is now a
273			// LeptonPointer, but they still work, so leave them as-is.
274
275			// Template functions must be defined here to be instantiated in other files.
276			template <class PartPtr> double transMass4j(const PartPtr leptonPtr) const {
277			double px = leptonPtr->px() + met->px();
278			double py = leptonPtr->py() + met->py();
279			double pz = 0.0;
280			double et = leptonPtr->et() + met->et();
281			for (unsigned short jetIndex = 0; jetIndex < 4 && jetIndex < goodJets.size(); ++jetIndex) {
282			px += goodJets.at(jetIndex)->px();
283			py += goodJets.at(jetIndex)->py();
284			et += goodJets.at(jetIndex)->et();
285			}
286			Particle mt(et, px, py, pz);
287			return (mt.mass());
288			}
289
290			template <class PartPtr> double transMass2j(const PartPtr leptonPtr) const {
291			double px = leptonPtr->px() + met->px();
292			double py = leptonPtr->py() + met->py();
293			double pz = 0.0;
294			double et = leptonPtr->et() + met->et();
295			if (goodBJets.size() > 0) {
296			px += goodBJets.front()->px();
297			py += goodBJets.front()->py();
298			et += goodBJets.front()->et();
299			}
300			for (unsigned short jetIndex = 0; jetIndex < 2 && jetIndex < goodJets.size(); ++jetIndex) {
301			if (goodBJets.size() <= 0 \|\| goodJets.at(jetIndex) != goodBJets.front()) {
302			px += goodJets.at(jetIndex)->px();
303			py += goodJets.at(jetIndex)->py();
304			et += goodJets.at(jetIndex)->et();
305			jetIndex = 2; // Terminate loop.
306			}
307			}
308			Particle mt(et, px, py, pz);
309			return (mt.mass());
310			}
311
312
313			template <class PartPtr> const ParticlePointer transMasslm1b(const PartPtr leptonPtr) const {
314			double px = leptonPtr->px() + met->px();
315			double py = leptonPtr->py() + met->py();
316			double pz = 0.0;
317			double et = leptonPtr->et() + met->et();
318			if (goodBJets.size() > 0) {
319			px += goodBJets.front()->px();
320			py += goodBJets.front()->py();
321			et += goodBJets.front()->et();
322			}
323			return (ParticlePointer(new Particle(et, px, py, pz)));
324			}
325
326
327			template <class PartPtr> const ParticlePointer massl1b(const PartPtr leptonPtr) const {
328			double px = leptonPtr->px();
329			double py = leptonPtr->py();
330			double pz = 0.0;
331			double et = leptonPtr->et();
332			if (goodBJets.size() > 0) {
333			px += goodBJets.front()->px();
334			py += goodBJets.front()->py();
335			et += goodBJets.front()->et();
336			}
337			return (ParticlePointer(new Particle(et, px, py, pz)));
338			}
339
340
341			template <class PartPtr> double deltaPhiTops(const PartPtr leptonPtr) const {
342			double px = 0.0, py = 0.0, pz = 0.0, et = 0.0;
343			for (unsigned short jetIndex = 1; jetIndex < 4 && jetIndex < goodJets.size(); ++jetIndex) {
344			px += goodJets.at(jetIndex)->px();
345			py += goodJets.at(jetIndex)->py();
346			et += goodJets.at(jetIndex)->et();
347			}
348			ParticlePointer mt = ParticlePointer(new Particle(et, px, py, pz));
349			return (transMasslm1b(leptonPtr)->deltaPhi(mt));
350			}
351
352
353			template <class PartPtr> double deltaPhiLepJet(const PartPtr leptonPtr) const {
354			if (goodJets.size() > 0)
355			return (leptonPtr->deltaPhi(goodJets.front()));
356			return (0.0);
357			}
358
359
360			JetPointer dJetFromWp;
361			short dJetFromWpIndex;
362			};
363
364
365			class TwoNonResTops : public TopPlusXCandidates {
366			public:
367			TwoNonResTops();
368			TwoNonResTops(const Event& event);
369			virtual ~TwoNonResTops();
370
371			void recoNonResTops(LeptonPointer lepton);
372			void recoNonResTopsWdjet(LeptonPointer lepton);
373			void recoWpFrom1Top(LeptonPointer lepton);
374			virtual double getGlobalChi2() const;
375			virtual const JetPointer getLtNonTopJet() const;
376			virtual const ParticlePointer getWprime() const;
377			virtual const ParticlePointer getBtBWprime() const;
378			virtual const ParticlePointer getNegWprime() const;
379			virtual const ParticlePointer getNegWprimeBad() const;
380			virtual double getHadTopDAngle() const;
381			virtual void getTrueWpChain();
382			virtual MCParticlePointer getWpTru() const;
383			virtual MCParticlePointer getWpTopTru() const;
384			virtual MCParticlePointer getSpecTop() const;
385			virtual MCParticlePointer getWpTopBTru() const;
386			virtual MCParticlePointer getSpecTopB() const;
387			virtual MCParticlePointer getWpDDauTru() const;
388			virtual double getTotalChi2DJ(unsigned short neutrinoSolution) const;
389
390			template <class PartPtr> double deltaPhiLepDJet(const PartPtr leptonPtr) const {
391			if (goodJets.size() > 4)
392			return (leptonPtr->deltaPhi(getLtNonTopJet()));
393			return (0.0);
394			}
395
396			ParticlePointer wpFrom1Top, wpBadFrom1Top;
397
398			protected:
399			MCParticlePointer wpTru, wpTopTru, specTopTru, wpDDauTru;
400			MCParticlePointer wpTopBTru, specTopBTru;
401			bool wpGenParticlesSet;
402			ParticlePointer topFromWp;
403			};
404
405
406			class LeptoTopNoMassConstraint : public TopNoMassConstraint {
407			public:
408			LeptoTopNoMassConstraint();
409			LeptoTopNoMassConstraint(const Event& event);
410			virtual ~LeptoTopNoMassConstraint();
411
412			// virtual bool passesFullEPlusJetSelection() const;
413			virtual void inspectReconstructedEvent() const;
414
415			};
416
417			}
418
419			#endif /* TOPLIKECANDIDATE_H_ */