#include <TtSemiLepJetCombMVAComputer.h>

Inheritance diagram for TtSemiLepJetCombMVAComputer:

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

	~TtSemiLepJetCombMVAComputer () override

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

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)

virtual	~ProducerBase () noexcept(false)

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

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

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

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	beginJob () override

void	endJob () override

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

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

edm::EDGetTokenT< edm::View< reco::RecoCandidate > >	lepsToken_

int	maxNComb_

int	maxNJets_

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

PhysicsTools::MVAComputerCache	mvaComputer

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)

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)

Detailed Description

Definition at line 21 of file TtSemiLepJetCombMVAComputer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 5 of file TtSemiLepJetCombMVAComputer.cc.

                                                                                   :
   lepsToken_    (consumes< edm::View<reco::RecoCandidate>>(cfg.getParameter<edm::InputTag>("leps"))),
   jetsToken_    (consumes< std::vector<pat::Jet> >(cfg.getParameter<edm::InputTag>("jets"))),
   metsToken_    (consumes< std::vector<pat::MET> >(cfg.getParameter<edm::InputTag>("mets"))),
   maxNJets_(cfg.getParameter<int>("maxNJets")),
   maxNComb_(cfg.getParameter<int>("maxNComb"))
 {
   produces<std::vector<std::vector<int> > >();
   produces<std::vector<double>            >("Discriminators");
   produces<std::string                    >("Method");
   produces<int                            >("NumberOfConsideredJets");
 }

TtSemiLepJetCombMVAComputer::~TtSemiLepJetCombMVAComputer ( )

override

Definition at line 18 of file TtSemiLepJetCombMVAComputer.cc.

19 {

20 }

Member Function Documentation

void TtSemiLepJetCombMVAComputer::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 131 of file TtSemiLepJetCombMVAComputer.cc.

132 {

133 }

void TtSemiLepJetCombMVAComputer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 136 of file TtSemiLepJetCombMVAComputer.cc.

137 {

138 }

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

overrideprivate

Definition at line 23 of file TtSemiLepJetCombMVAComputer.cc.

References PhysicsTools::MVAComputer::eval(), evaluateTtSemiLepJetComb(), edm::eventsetup::EventSetupRecord::get(), edm::Event::getByToken(), mps_fire::i, createfilelist::int, fwrapper::jets, jetsToken_, lepsToken_, AK4GenJetFlavourInfos_cfi::leptons, TtSemiLepEvtPartons::LightQ, TtSemiLepEvtPartons::LightQBar, maxNComb_, maxNJets_, RazorAnalyzer::met, TtSemiLepSignalSelMVAComputer_cfi::mets, metsToken_, eostools::move(), mvaComputer, stdcomb::next_combination(), nPartons, edm::Event::put(), GeneralSetup::setup(), AlCaHLTBitMon_QueryRunRegistry::string, PhysicsTools::MVAComputerCache::update(), and MuonErrorMatrixValues_cff::values.

 {
   std::unique_ptr<std::vector<std::vector<int> > > pOut    (new std::vector<std::vector<int> >);
   std::unique_ptr<std::vector<double>            > pOutDisc(new std::vector<double>);
   std::unique_ptr<std::string                    > pOutMeth(new std::string);
   std::unique_ptr<int                            > pJetsConsidered(new int);
 
   mvaComputer.update<TtSemiLepJetCombMVARcd>(setup, "ttSemiLepJetCombMVA");
 
   // read name of the processor that provides the MVA discriminator
   // (to be used as meta information)
   edm::ESHandle<PhysicsTools::Calibration::MVAComputerContainer> calibContainer;
   setup.get<TtSemiLepJetCombMVARcd>().get( calibContainer );
   std::vector<PhysicsTools::Calibration::VarProcessor*> processors
     = (calibContainer->find("ttSemiLepJetCombMVA")).getProcessors();
   *pOutMeth = ( processors[ processors.size()-3 ] )->getInstanceName();
   evt.put(std::move(pOutMeth), "Method");
 
   // get lepton, jets and mets
   edm::Handle< edm::View<reco::RecoCandidate> > leptons;
   evt.getByToken(lepsToken_, leptons);
 
   edm::Handle< std::vector<pat::Jet> > jets;
   evt.getByToken(jetsToken_, jets);
 
   edm::Handle< std::vector<pat::MET> > mets;
   evt.getByToken(metsToken_, mets);
 
   const unsigned int nPartons = 4;
 
   // skip events with no appropriate lepton candidate,
   // empty METs vector or less jets than partons
   if( leptons->empty() || mets->empty() || jets->size() < nPartons ) {
     std::vector<int> invalidCombi;
     for(unsigned int i = 0; i < nPartons; ++i)
       invalidCombi.push_back( -1 );
     pOut->push_back( invalidCombi );
     evt.put(std::move(pOut));
     pOutDisc->push_back( 0. );
     evt.put(std::move(pOutDisc), "Discriminators");
     *pJetsConsidered = jets->size();
     evt.put(std::move(pJetsConsidered), "NumberOfConsideredJets");
     return;
   }
 
   const math::XYZTLorentzVector lepton = leptons->begin()->p4();
 
   const pat::MET *met = &(*mets)[0];
 
   // analyze jet combinations
   std::vector<int> jetIndices;
   for(unsigned int i=0; i<jets->size(); ++i){
     if(maxNJets_ >= (int) nPartons && maxNJets_ == (int) i) {
       *pJetsConsidered = i;
       break;
     }
     jetIndices.push_back(i);
   }
 
   std::vector<int> combi;
   for(unsigned int i=0; i<nPartons; ++i)
     combi.push_back(i);
 
   typedef std::pair<double, std::vector<int> > discCombPair;
   std::list<discCombPair> discCombList;
 
   do{
     for(int cnt = 0; cnt < TMath::Factorial( combi.size() ); ++cnt){
       // take into account indistinguishability of the two jets from the hadr. W decay,
       // reduces combinatorics by a factor of 2
       if(combi[TtSemiLepEvtPartons::LightQ] < combi[TtSemiLepEvtPartons::LightQBar]) {
 
     TtSemiLepJetComb jetComb(*jets, combi, lepton, *met);
 
     // feed MVA input variables into a ValueList
     PhysicsTools::Variable::ValueList values;
     evaluateTtSemiLepJetComb(values, jetComb);
 
     // get discriminator from the MVAComputer
     double discrim = mvaComputer->eval( values );
 
     discCombList.push_back( std::make_pair(discrim, combi) );
 
       }
       next_permutation( combi.begin() , combi.end() );
     }
   }
   while(stdcomb::next_combination( jetIndices.begin(), jetIndices.end(), combi.begin(), combi.end() ));
 
   // sort results w.r.t. discriminator values
   discCombList.sort();
 
   // write result into the event
   // (starting with the JetComb having the highest discriminator value -> reverse iterator)
   unsigned int iDiscComb = 0;
   typedef std::list<discCombPair>::reverse_iterator discCombIterator;
   for(discCombIterator discCombPair = discCombList.rbegin(); discCombPair != discCombList.rend(); ++discCombPair) {
     if(maxNComb_ >= 1 && iDiscComb == (unsigned int) maxNComb_) break;
     pOut    ->push_back( discCombPair->second );
     pOutDisc->push_back( discCombPair->first  );
     iDiscComb++;
   }
   evt.put(std::move(pOut));
   evt.put(std::move(pOutDisc), "Discriminators");
   evt.put(std::move(pJetsConsidered), "NumberOfConsideredJets");
 }