#include <TtSemiLepJetCombMVATrainer.h>

Inheritance diagram for TtSemiLepJetCombMVATrainer:

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

	~TtSemiLepJetCombMVATrainer ()

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

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

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

	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

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) 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	analyze (const edm::Event &evt, const edm::EventSetup &setup)

virtual void	beginJob ()

virtual void	endJob ()

WDecay::LeptonType	readLeptonType (const std::string &str)

Private Attributes
edm::EDGetTokenT< TtGenEvent >	genEvtToken_

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

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

WDecay::LeptonType	leptonType_

edm::EDGetTokenT< std::vector < std::vector< int > > >	matchingToken_

int	maxNJets_

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

PhysicsTools::MVAComputerCache	mvaComputer

unsigned int	nEvents [5]

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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 25 of file TtSemiLepJetCombMVATrainer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 14 of file TtSemiLepJetCombMVATrainer.cc.

                                                                                 :
   genEvtToken_      (consumes<TtGenEvent>(edm::InputTag("genEvt"))),
   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"    ))),
   matchingToken_  (mayConsume< std::vector< std::vector<int> > >(cfg.getParameter<edm::InputTag>("matching"))),
   maxNJets_  (cfg.getParameter<int>          ("maxNJets")),
   leptonType_(readLeptonType(cfg.getParameter<std::string>("leptonType")))
 {
 }

TtSemiLepJetCombMVATrainer::~TtSemiLepJetCombMVATrainer ( )

Definition at line 25 of file TtSemiLepJetCombMVATrainer.cc.

26 {

27 }

Member Function Documentation

void TtSemiLepJetCombMVATrainer::analyze	(	const edm::Event &	evt,
		const edm::EventSetup &	setup
	)

privatevirtual

Implements edm::EDAnalyzer.

Definition at line 37 of file TtSemiLepJetCombMVATrainer.cc.

References PhysicsTools::Variable::ValueList::add(), PhysicsTools::MVAComputer::eval(), evaluateTtSemiLepJetComb(), TtGenEvtProducer_cfi::genEvt, genEvtToken_, edm::Event::getByToken(), i, fwrapper::jets, jetsToken_, PhysicsTools::MVATrainer::kTargetId, lepsToken_, HLT_25ns14e33_v1_cff::leptons, leptonType_, TtSemiLepEvtPartons::LightQ, TtSemiLepEvtPartons::LightQBar, matchingToken_, maxNJets_, objects.METAnalyzer::met, metsToken_, mvaComputer, nEvents, stdcomb::next_combination(), nPartons, HcalObjRepresent::setup(), PhysicsTools::MVAComputerCache::update(), and makeHLTPrescaleTable::values.

 {
   mvaComputer.update<TtSemiLepJetCombMVARcd>("trainer", setup, "ttSemiLepJetCombMVA");
 
   // can occur in the last iteration when the
   // MVATrainer is about to save the result
   if(!mvaComputer) return;
 
   nEvents[0]++;
 
   edm::Handle<TtGenEvent> genEvt;
   evt.getByToken(genEvtToken_, genEvt);
 
   edm::Handle< edm::View<reco::RecoCandidate> > leptons;
   evt.getByToken(lepsToken_, leptons);
 
   // skip events with no appropriate lepton candidate
   if( leptons->empty() ) return;
 
   nEvents[1]++;
 
   const math::XYZTLorentzVector lepton = leptons->begin()->p4();
 
   edm::Handle< std::vector<pat::MET> > mets;
   evt.getByToken(metsToken_, mets);
 
   // skip events with empty METs vector
   if( mets->empty() ) return;
 
   nEvents[2]++;
 
   const pat::MET *met = &(*mets)[0];
 
   edm::Handle< std::vector<pat::Jet> > jets;
   evt.getByToken(jetsToken_, jets);
 
   // skip events with less jets than partons
   unsigned int nPartons = 4;
   if( jets->size() < nPartons ) return;
 
   nEvents[3]++;
 
   edm::Handle< std::vector< std::vector<int> > > matchingHandle;
   std::vector<int> matching;
   // get jet-parton matching if signal channel
   if(genEvt->semiLeptonicChannel() == leptonType_) {
     evt.getByToken(matchingToken_, matchingHandle);
     if( matchingHandle->empty() )
       throw cms::Exception("EmptyProduct")
     << "Empty vector from jet-parton matching. This should not happen! \n";
     matching = *(matchingHandle->begin());
     if(matching.size() < nPartons) return;
     // skip events that were affected by the outlier
     // rejection in the jet-parton matching
     for(unsigned int i = 0; i < matching.size(); ++i) {
       if(matching[i] == -3) continue; // -3: parton was chosen to be excluded from jet-parton matching
       if(matching[i] < 0 || matching[i] >= (int)jets->size())
     return;
     }
   }
   // use dummy for matching if not signal channel
   else
     for(unsigned int i = 0; i < nPartons; i++)
       matching.push_back( -1 );
 
   nEvents[4]++;
 
   // take into account indistinguishability of the two jets from the hadr. W decay,
   // reduces combinatorics by a factor of 2
   if(matching[TtSemiLepEvtPartons::LightQ] > matching[TtSemiLepEvtPartons::LightQBar]) {
     int iTemp = matching[TtSemiLepEvtPartons::LightQ];
     matching[TtSemiLepEvtPartons::LightQ] = matching[TtSemiLepEvtPartons::LightQBar];
     matching[TtSemiLepEvtPartons::LightQBar] = iTemp;
   }
 
   std::vector<int> jetIndices;
   for(unsigned int i=0; i<jets->size(); ++i) {
     if(maxNJets_ >= (int) nPartons && i == (unsigned int) maxNJets_) break;
     jetIndices.push_back(i);
   }
 
   std::vector<int> combi;
   for(unsigned int i = 0; i < nPartons; ++i)
     combi.push_back(i);
 
   // use a ValueList to collect all variables for the MVAComputer
   PhysicsTools::Variable::ValueList values;
 
   // set target variable to false like for background
   // this is necessary when passing all combinations at once
   values.add( PhysicsTools::Variable::Value(PhysicsTools::MVATrainer::kTargetId, false) );
 
   do {
     // number of possible combinations from number of partons: e.g. 4! = 24
     for(unsigned 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);
 
     bool trueCombi = false;
     // true combination only if signal channel
     // and in agreement with matching
     if(genEvt->semiLeptonicChannel()==leptonType_) {
       trueCombi = true;
       for(unsigned int i = 0; i < matching.size(); ++i) {
         if(combi[i]!=matching[i] && matching[i]!=-3) {
           trueCombi = false;
           break;
         }
       }
     }
 
     // feed MVA input variables for this jetComb into the ValueList
     values.add("target", trueCombi);
     evaluateTtSemiLepJetComb(values, jetComb);
 
       }
 
       next_permutation( combi.begin() , combi.end() );
     }
   }
   while(stdcomb::next_combination( jetIndices.begin(), jetIndices.end(), combi.begin(), combi.end() ));
 
   // pass MVA input variables for all jet combinations in this event
   // to the MVAComputer for training
   mvaComputer->eval( values );
 }

void TtSemiLepJetCombMVATrainer::beginJob ( void )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 30 of file TtSemiLepJetCombMVATrainer.cc.

References i, and nEvents.

 {
   for(unsigned int i = 0; i < 5; i++)
     nEvents[i] = 0;
 }

void TtSemiLepJetCombMVATrainer::endJob ( void )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 169 of file TtSemiLepJetCombMVATrainer.cc.

References cmsBatch::log, and nEvents.

 {
   edm::LogInfo log("TtSemiLepJetCombMVATrainer");
   log << "Number of events... \n"
       << "...passed to the trainer                   : " << std::setw(7) << nEvents[0] << "\n"
       << "...rejected since no lepton candidate      : " << std::setw(7) << nEvents[0]-nEvents[1] << "\n"
       << "...rejected since no MET object            : " << std::setw(7) << nEvents[1]-nEvents[2] << "\n"
       << "...rejected since not enough jets          : " << std::setw(7) << nEvents[2]-nEvents[3] << "\n"
       << "...rejected due to bad jet-parton matching : " << std::setw(7) << nEvents[3]-nEvents[4] << "\n"
       << "...accepted for training                   : " << std::setw(7) << nEvents[4] << "\n";
 }

WDecay::LeptonType TtSemiLepJetCombMVATrainer::readLeptonType ( const std::string & str )

private

Definition at line 182 of file TtSemiLepJetCombMVATrainer.cc.

References Exception, WDecay::kElec, WDecay::kMuon, and WDecay::kTau.

 {
   if     (str == "kElec") return WDecay::kElec;
   else if(str == "kMuon") return WDecay::kMuon;
   else if(str == "kTau" ) return WDecay::kTau;
   else throw cms::Exception("Configuration")
     << "Chosen leptonType is not supported: " << str << "\n";
 }