Inheritance diagram for TtFullLepHypKinSolution:

Public Member Functions
	TtFullLepHypKinSolution (const edm::ParameterSet &)

Public Member Functions inherited from TtFullLepHypothesis
	TtFullLepHypothesis (const edm::ParameterSet &)
	default constructor More...

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Member Functions
void	buildHypo (edm::Event &evt, const edm::Handle< std::vector< pat::Electron > > &elecs, const edm::Handle< std::vector< pat::Muon > > &mus, const edm::Handle< std::vector< pat::Jet > > &jets, const edm::Handle< std::vector< pat::MET > > &mets, std::vector< int > &match, const unsigned int iComb) override
	build event hypothesis from the reco objects of a full-leptonic event More...

void	buildKey () override
	build the event hypothesis key More...

Private Attributes
edm::EDGetTokenT< std::vector< reco::LeafCandidate > >	nuBarsToken_

edm::EDGetTokenT< std::vector< reco::LeafCandidate > >	nusToken_

edm::EDGetTokenT< std::vector< double > >	solWeightToken_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Protected Member Functions inherited from TtFullLepHypothesis
reco::CompositeCandidate	hypo ()
	return event hypothesis More...

bool	isValid (const int &idx, const edm::Handle< std::vector< pat::Jet > > &jets)
	check if index is in valid range of selected jets More...

int	key () const
	return key More...

template<typename C >
std::unique_ptr< reco::ShallowClonePtrCandidate >	makeCandidate (const edm::Handle< C > &handle, const int &idx)
	use one object in a collection to set a ShallowClonePtrCandidate More...

std::unique_ptr< reco::ShallowClonePtrCandidate >	makeCandidate (const edm::Handle< std::vector< pat::Jet > > &handle, const int &idx, const std::string &correctionLevel)
	use one object in a jet collection to set a ShallowClonePtrCandidate with proper jet corrections More...

void	produce (edm::Event &, const edm::EventSetup &) override
	produce the event hypothesis as CompositeCandidate and Key More...

void	resetCandidates ()
	reset candidate pointers before hypo build process More...

Protected Attributes inherited from TtFullLepHypothesis
std::unique_ptr< reco::ShallowClonePtrCandidate >	b_

std::unique_ptr< reco::ShallowClonePtrCandidate >	bBar_

edm::EDGetTokenT< std::vector< pat::Electron > >	elecsToken_

bool	getMatch_

std::string	jetCorrectionLevel_

edm::EDGetTokenT< std::vector< pat::Jet > >	jetsToken_

int	key_
	hypothesis key (to be set by the buildKey function) More...

std::unique_ptr< reco::ShallowClonePtrCandidate >	lepton_

std::unique_ptr< reco::ShallowClonePtrCandidate >	leptonBar_

edm::EDGetTokenT< std::vector< std::vector< int > > >	matchToken_
	input label for all necessary collections More...

edm::EDGetTokenT< std::vector< pat::MET > >	metsToken_

edm::EDGetTokenT< std::vector< pat::Muon > >	musToken_

std::unique_ptr< reco::ShallowClonePtrCandidate >	neutrino_

std::unique_ptr< reco::ShallowClonePtrCandidate >	neutrinoBar_

std::unique_ptr< reco::LeafCandidate >	recNu
	candidates needed for the genmatch hypothesis More...

std::unique_ptr< reco::LeafCandidate >	recNuBar

Detailed Description

Definition at line 4 of file TtFullLepHypKinSolution.cc.

Constructor & Destructor Documentation

◆ TtFullLepHypKinSolution()

TtFullLepHypKinSolution::TtFullLepHypKinSolution ( const edm::ParameterSet & cfg )

explicit

Definition at line 26 of file TtFullLepHypKinSolution.cc.

     : TtFullLepHypothesis(cfg),
       nusToken_(consumes<std::vector<reco::LeafCandidate> >(cfg.getParameter<edm::InputTag>("Neutrinos"))),
       nuBarsToken_(consumes<std::vector<reco::LeafCandidate> >(cfg.getParameter<edm::InputTag>("NeutrinoBars"))),
       solWeightToken_(consumes<std::vector<double> >(cfg.getParameter<edm::InputTag>("solutionWeight"))) {}

Member Function Documentation

◆ buildHypo()

void TtFullLepHypKinSolution::buildHypo	(	edm::Event &	evt,
		const edm::Handle< std::vector< pat::Electron > > &	elecs,
		const edm::Handle< std::vector< pat::Muon > > &	mus,
		const edm::Handle< std::vector< pat::Jet > > &	jets,
		const edm::Handle< std::vector< pat::MET > > &	mets,
		std::vector< int > &	match,
		const unsigned int	iComb
	)

overrideprivatevirtual

build event hypothesis from the reco objects of a full-leptonic event

Implements TtFullLepHypothesis.

Definition at line 32 of file TtFullLepHypKinSolution.cc.

References TtFullLepHypothesis::b_, TtFullLepHypothesis::bBar_, singleTopDQM_cfi::elecs, edm::Event::getByToken(), TtFullLepHypothesis::jetCorrectionLevel_, singleTopDQM_cfi::jets, TtFullLepHypothesis::lepton_, TtFullLepHypothesis::leptonBar_, TtFullLepHypothesis::makeCandidate(), match(), TtFullLepHypothesis::neutrino_, TtFullLepHypothesis::neutrinoBar_, nuBarsToken_, nusToken_, TtFullLepEvtBuilder_cfi::solWeight, and solWeightToken_.

                                                                   {
   edm::Handle<std::vector<double> > solWeight;
   //   edm::Handle<std::vector<std::vector<int> > >   idcsVec;
   edm::Handle<std::vector<reco::LeafCandidate> > nus;
   edm::Handle<std::vector<reco::LeafCandidate> > nuBars;
 
   evt.getByToken(solWeightToken_, solWeight);
   //   evt.getByToken(particleIdcsToken_, idcsVec  );
   evt.getByToken(nusToken_, nus);
   evt.getByToken(nuBarsToken_, nuBars);
 
   if ((*solWeight)[iComb] < 0) {
     // create empty hypothesis if no solution exists
     return;
   }
 
   // -----------------------------------------------------
   // add jets
   // -----------------------------------------------------
   if (!jets->empty()) {
     b_ = makeCandidate(jets, match[0], jetCorrectionLevel_);
     bBar_ = makeCandidate(jets, match[1], jetCorrectionLevel_);
   }
   // -----------------------------------------------------
   // add leptons
   // -----------------------------------------------------
   if (!elecs->empty() && match[2] >= 0)
     leptonBar_ = makeCandidate(elecs, match[2]);
 
   if (!elecs->empty() && match[3] >= 0)
     lepton_ = makeCandidate(elecs, match[3]);
 
   if (!mus->empty() && match[4] >= 0 && match[2] < 0)
     leptonBar_ = makeCandidate(mus, match[4]);
 
   // this 'else' happens if you have a wrong charge electron-muon-
   // solution so the indices are (b-idx, bbar-idx, 0, -1, 0, -1)
   // so the mu^+ is stored as l^-
   else if (!mus->empty() && match[4] >= 0)
     lepton_ = makeCandidate(mus, match[4]);
 
   if (!mus->empty() && match[5] >= 0 && match[3] < 0)
     lepton_ = makeCandidate(mus, match[5]);
 
   // this 'else' happens if you have a wrong charge electron-muon-
   // solution so the indices are (b-idx, bbar-idx, -1, 0, -1, 0)
   // so the mu^- is stored as l^+
   else if (!mus->empty() && match[5] >= 0)
     leptonBar_ = makeCandidate(mus, match[5]);
 
   // -----------------------------------------------------
   // add neutrinos
   // -----------------------------------------------------
   if (!nus->empty())
     neutrino_ = makeCandidate(nus, iComb);
 
   if (!nuBars->empty())
     neutrinoBar_ = makeCandidate(nuBars, iComb);
 }