TtSemiLepJetCombMVAComputer.cc

Go to the documentation of this file.

#include "PhysicsTools/JetMCUtils/interface/combination.h"

#include "TopQuarkAnalysis/TopJetCombination/plugins/TtSemiLepJetCombMVAComputer.h"

TtSemiLepJetCombMVAComputer::TtSemiLepJetCombMVAComputer(const edm::ParameterSet& cfg):
  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()
{
}

void
TtSemiLepJetCombMVAComputer::produce(edm::Event& evt, const edm::EventSetup& setup)
{
  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");
}

void
TtSemiLepJetCombMVAComputer::beginJob()
{
}

void
TtSemiLepJetCombMVAComputer::endJob()
{
}

// implement the plugins for the computer container
// -> register TtSemiLepJetCombMVARcd
// -> define TtSemiLepJetCombMVAFileSource
MVA_COMPUTER_CONTAINER_IMPLEMENT(TtSemiLepJetCombMVA);