#include <TtFullLepHypothesis.h>

Inheritance diagram for TtFullLepHypothesis:

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

	~TtFullLepHypothesis () override
	default destructor More...

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

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Protected 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)=0
	build event hypothesis from the reco objects of a semi-leptonic event More...

virtual void	buildKey ()=0
	build the event hypothesis key More...

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

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

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::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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Detailed Description

Definition at line 34 of file TtFullLepHypothesis.h.

Constructor & Destructor Documentation

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

explicit

default constructor

Definition at line 5 of file TtFullLepHypothesis.cc.

References edm::ParameterSet::exists(), getMatch_, edm::ParameterSet::getParameter(), jetCorrectionLevel_, matchToken_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                   :
   elecsToken_(consumes<std::vector<pat::Electron> >(cfg.getParameter<edm::InputTag>("electrons"))),
   musToken_  (consumes<std::vector<pat::Muon> >(cfg.getParameter<edm::InputTag>("muons"))),
   jetsToken_ (consumes<std::vector<pat::Jet> >(cfg.getParameter<edm::InputTag>("jets"))),
   metsToken_ (consumes<std::vector<pat::MET> >(cfg.getParameter<edm::InputTag>("mets"))),
 
   lepton_(nullptr), leptonBar_(nullptr), b_(nullptr),
   bBar_(nullptr), neutrino_(nullptr), neutrinoBar_(nullptr)
 {
   getMatch_ = false;
   if( cfg.exists("match") ) {
     getMatch_ = true;
     matchToken_ = consumes<std::vector<std::vector<int> > >(cfg.getParameter<edm::InputTag>("match"));
   }
   // if no other correction is given apply L3 (abs) correction
   jetCorrectionLevel_ = "abs";
   if( cfg.exists("jetCorrectionLevel") ) {
     jetCorrectionLevel_ = cfg.getParameter<std::string>("jetCorrectionLevel");
   }
   else{ // if no other correction is given apply L3 (abs) correction
     jetCorrectionLevel_ = "abs";
   }
   produces<std::vector<std::pair<reco::CompositeCandidate, std::vector<int> > > >();
   produces<int>("Key");
 }

TtFullLepHypothesis::~TtFullLepHypothesis ( )

override

default destructor

Definition at line 32 of file TtFullLepHypothesis.cc.

References b_, bBar_, lepton_, leptonBar_, neutrino_, and neutrinoBar_.

 {
   if( lepton_      ) delete lepton_;
   if( leptonBar_   ) delete leptonBar_;
   if( b_           ) delete b_;
   if( bBar_        ) delete bBar_;
   if( neutrino_    ) delete neutrino_;
   if( neutrinoBar_ ) delete neutrinoBar_;
   //if( met_         ) delete met_;
 }

Member Function Documentation

virtual void TtFullLepHypothesis::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
	)

protectedpure virtual

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

Implemented in TtFullLepHypGenMatch, and TtFullLepHypKinSolution.

Referenced by isValid(), and produce().

virtual void TtFullLepHypothesis::buildKey ( )

protectedpure virtual

build the event hypothesis key

Implemented in TtFullLepHypGenMatch, and TtFullLepHypKinSolution.

Referenced by isValid(), and produce().

reco::CompositeCandidate TtFullLepHypothesis::hypo ( )

protected

return event hypothesis

Definition at line 111 of file TtFullLepHypothesis.cc.

Referenced by key(), and produce().

 {
   // check for sanity of the hypothesis
   if( !lepton_ || !leptonBar_ || !b_ || !bBar_ ){
     return reco::CompositeCandidate();
   }
 
   if( key()==TtFullLeptonicEvent::kGenMatch && (!recNu || !recNuBar) ){
     edm::LogInfo("TtFullHypothesis") << "no neutrinos for gen match" << std::endl;
     return reco::CompositeCandidate();
   }
   if( key()==TtFullLeptonicEvent::kKinSolution && (!neutrino_ || !neutrinoBar_) ){
     edm::LogInfo("TtFullHypothesis") << "no neutrinos for kin solution" << std::endl;
     return reco::CompositeCandidate();
   }
 
   // setup transient references
   reco::CompositeCandidate hyp, Top, WPlus, TopBar, WMinus;
 
   AddFourMomenta addFourMomenta;
 
   // build up the top branch
   WPlus.addDaughter(*leptonBar_, TtFullLepDaughter::LepBar);
   if(key()==TtFullLeptonicEvent::kKinSolution)
     WPlus.addDaughter(*neutrino_, TtFullLepDaughter::Nu);
   else if(key()==TtFullLeptonicEvent::kGenMatch)
     WPlus.addDaughter(*recNu, TtFullLepDaughter::Nu);
   addFourMomenta.set(WPlus);
   Top.addDaughter(WPlus, TtFullLepDaughter::WPlus);
   Top.addDaughter(*b_,TtFullLepDaughter::B);
   addFourMomenta.set(Top);
 
   // build up the anti top branch
   WMinus.addDaughter(*lepton_, TtFullLepDaughter::Lep);
   if(key()==TtFullLeptonicEvent::kKinSolution)
     WMinus.addDaughter(*neutrinoBar_, TtFullLepDaughter::NuBar);
   else if(key()==TtFullLeptonicEvent::kGenMatch)
     WMinus.addDaughter(*recNuBar, TtFullLepDaughter::NuBar);
   addFourMomenta.set(WMinus);
   TopBar.addDaughter(WMinus, TtFullLepDaughter::WMinus);
   TopBar.addDaughter(*bBar_, TtFullLepDaughter::BBar);
   addFourMomenta.set(TopBar);
 
   // build ttbar hypothesis
   hyp.addDaughter(Top, TtFullLepDaughter::Top);
   hyp.addDaughter(TopBar, TtFullLepDaughter::TopBar);
   addFourMomenta.set( hyp );
 
   // the four momentum of the met is not added to the hypothesis
   // because it is allready included through the neutrinos
   //hyp.addDaughter(*met_, TtFullLepDaughter::Met);
   return hyp;
 }

bool TtFullLepHypothesis::isValid	(	const int &	idx,
		const edm::Handle< std::vector< pat::Jet > > &	jets
	)

inlineprotected

check if index is in valid range of selected jets

Definition at line 57 of file TtFullLepHypothesis.h.

References buildHypo(), buildKey(), PatTopSelectionAnalyzer_cfi::elecs, fwrapper::jets, match(), and TtSemiLepSignalSelMVAComputer_cfi::mets.

Referenced by ntupleDataFormat._Object::_checkIsValid(), TtFullLepHypGenMatch::buildHypo(), and core.AutoHandle.AutoHandle::ReallyLoad().

57 { return (0<=idx && idx<(int)jets->size()); };

training_settings.idx

idx

Definition: training_settings.py:16

int TtFullLepHypothesis::key ( ) const

inlineprotected

return key

Definition at line 53 of file TtFullLepHypothesis.h.

References hypo(), and key_.

Referenced by hypo(), and produce().

53 { return key_; };

TtFullLepHypothesis::key_

int key_

hypothesis key (to be set by the buildKey function)

Definition: TtFullLepHypothesis.h:89

void TtFullLepHypothesis::produce	(	edm::Event &	evt,
		const edm::EventSetup &	setup
	)

overrideprotected

produce the event hypothesis as CompositeCandidate and Key

Definition at line 45 of file TtFullLepHypothesis.cc.

References buildHypo(), buildKey(), PatTopSelectionAnalyzer_cfi::elecs, elecsToken_, edm::Event::getByToken(), getMatch_, hypo(), mps_fire::i, fwrapper::jets, jetsToken_, key(), match(), matchToken_, TtSemiLepSignalSelMVAComputer_cfi::mets, metsToken_, eostools::move(), musToken_, edm::Event::put(), and resetCandidates().

 {
   edm::Handle<std::vector<pat::Electron> > elecs;
   evt.getByToken(elecsToken_, elecs);
 
   edm::Handle<std::vector<pat::Muon> > mus;
   evt.getByToken(musToken_, mus);
 
   edm::Handle<std::vector<pat::Jet> > jets;
   evt.getByToken(jetsToken_, jets);
 
   edm::Handle<std::vector<pat::MET> > mets;
   evt.getByToken(metsToken_, mets);
 
   std::vector<std::vector<int> > matchVec;
   if( getMatch_ ) {
     edm::Handle<std::vector<std::vector<int> > > matchHandle;
     evt.getByToken(matchToken_, matchHandle);;
     matchVec = *matchHandle;
   }
   else {
     std::vector<int> dummyMatch;
     for(unsigned int i = 0; i < 4; ++i)
       dummyMatch.push_back( -1 );
     matchVec.push_back( dummyMatch );
   }
 
   // declare unique_ptr for products
   std::unique_ptr<std::vector<std::pair<reco::CompositeCandidate, std::vector<int> > > >
     pOut( new std::vector<std::pair<reco::CompositeCandidate, std::vector<int> > > );
   std::unique_ptr<int> pKey(new int);
 
   // build and feed out key
   buildKey();
   *pKey=key();
   evt.put(std::move(pKey), "Key");
 
   // go through given vector of jet combinations
   unsigned int idMatch = 0;
   typedef std::vector<std::vector<int> >::iterator MatchVecIterator;
   for(MatchVecIterator match = matchVec.begin(); match != matchVec.end(); ++match) {
     // reset pointers
     resetCandidates();
     // build hypothesis
     buildHypo(evt, elecs, mus, jets, mets, *match, idMatch++);
     pOut->push_back( std::make_pair(hypo(), *match) );
   }
   // feed out hyps and matches
   evt.put(std::move(pOut));
 }

void TtFullLepHypothesis::resetCandidates ( )

protected

reset candidate pointers before hypo build process

Definition at line 98 of file TtFullLepHypothesis.cc.

References b_, bBar_, lepton_, leptonBar_, neutrino_, and neutrinoBar_.

Referenced by produce().

 {
   lepton_     = nullptr;
   leptonBar_  = nullptr;
   b_          = nullptr;
   bBar_       = nullptr;
   neutrino_   = nullptr;
   neutrinoBar_= nullptr;
   //met_        = 0;
 }

template<typename C >

void TtFullLepHypothesis::setCandidate	(	const edm::Handle< C > &	handle,
		const int &	idx,
		reco::ShallowClonePtrCandidate *&	clone
	)

protected

use one object in a collection to set a ShallowClonePtrCandidate

Definition at line 109 of file TtFullLepHypothesis.h.

References cmsBatch::handle, and training_settings::idx.

Referenced by TtFullLepHypKinSolution::buildHypo(), and TtFullLepHypGenMatch::buildHypo().

                                                                                                                   {
   typedef typename C::value_type O;
   edm::Ptr<O> ptr = edm::Ptr<O>(handle, idx);
   clone = new reco::ShallowClonePtrCandidate( ptr, ptr->charge(), ptr->p4(), ptr->vertex() );
 }

void TtFullLepHypothesis::setCandidate	(	const edm::Handle< std::vector< pat::Jet > > &	handle,
		const int &	idx,
		reco::ShallowClonePtrCandidate *&	clone,
		const std::string &	correctionLevel
	)

protected

use one object in a jet collection to set a ShallowClonePtrCandidate with proper jet corrections

Definition at line 167 of file TtFullLepHypothesis.cc.

References reco::LeafCandidate::charge(), pat::Jet::correctedJet(), cmsBatch::handle, training_settings::idx, jetCorrectionLevel_, reco::LeafCandidate::p4(), and reco::LeafCandidate::vertex().

 {
   edm::Ptr<pat::Jet> ptr = edm::Ptr<pat::Jet>(handle, idx);
   clone = new reco::ShallowClonePtrCandidate( ptr, ptr->charge(), ptr->correctedJet(jetCorrectionLevel_, "bottom").p4(), ptr->vertex() );
 }