#include <TtFullLepHypKinSolution.h>

Inheritance diagram for TtFullLepHypKinSolution:

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

	~TtFullLepHypKinSolution ()

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

	~TtFullLepHypothesis ()
	default destructor More...

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
virtual 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)
	build event hypothesis from the reco objects of a full-leptonic event More...

virtual void	buildKey ()
	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::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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...

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

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

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

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

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Protected Attributes inherited from TtFullLepHypothesis
reco::ShallowClonePtrCandidate *	b_

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...

reco::ShallowClonePtrCandidate *	lepton_

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_

reco::ShallowClonePtrCandidate *	neutrino_

reco::ShallowClonePtrCandidate *	neutrinoBar_

reco::LeafCandidate *	recNu
	candidates needed for the genmatch hypothesis More...

reco::LeafCandidate *	recNuBar

Detailed Description

Definition at line 6 of file TtFullLepHypKinSolution.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 5 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" )))
 {
 }

TtFullLepHypKinSolution::~TtFullLepHypKinSolution ( )

Definition at line 13 of file TtFullLepHypKinSolution.cc.

13 { }

Member Function Documentation

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
	)

privatevirtual

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

Implements TtFullLepHypothesis.

Definition at line 16 of file TtFullLepHypKinSolution.cc.

References TtFullLepHypothesis::b_, TtFullLepHypothesis::bBar_, edm::Event::getByToken(), TtFullLepHypothesis::jetCorrectionLevel_, fwrapper::jets, TtFullLepHypothesis::lepton_, TtFullLepHypothesis::leptonBar_, TtFullLepHypothesis::neutrino_, TtFullLepHypothesis::neutrinoBar_, nuBarsToken_, nusToken_, TtFullLepHypothesis::setCandidate(), 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() ){
     setCandidate(jets, match[0], b_   , jetCorrectionLevel_);
     setCandidate(jets, match[1], bBar_, jetCorrectionLevel_);
   }
   // -----------------------------------------------------
   // add leptons
   // -----------------------------------------------------
   if( !elecs->empty() && match[2]>=0)
     setCandidate(elecs,  match[2], leptonBar_);
 
   if( !elecs->empty() && match[3]>=0)
     setCandidate(elecs,  match[3], lepton_);
 
   if( !mus->empty() && match[4]>=0 && match[2]<0)
     setCandidate(mus,  match[4], leptonBar_);
 
   // 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)
     setCandidate(mus,  match[4], lepton_);
 
   if( !mus->empty()  && match[5]>=0 && match[3]<0)
     setCandidate(mus,  match[5], lepton_);
 
   // 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)
     setCandidate(mus,  match[5], leptonBar_);
 
   // -----------------------------------------------------
   // add neutrinos
   // -----------------------------------------------------
   if( !nus->empty() )
     setCandidate(nus,    iComb, neutrino_);
 
   if( !nuBars->empty() )
     setCandidate(nuBars, iComb, neutrinoBar_);
 
 }