TtFullLepHypothesis.cc

Go to the documentation of this file.

#include "CommonTools/CandUtils/interface/AddFourMomenta.h"
#include "TopQuarkAnalysis/TopJetCombination/interface/TtFullLepHypothesis.h"

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

void
TtFullLepHypothesis::produce(edm::Event& evt, const edm::EventSetup& setup)
{
  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()
{
  lepton_     = nullptr;
  leptonBar_  = nullptr;
  b_          = nullptr;
  bBar_       = nullptr;
  neutrino_   = nullptr;
  neutrinoBar_= nullptr;
  //met_        = 0;
}

reco::CompositeCandidate
TtFullLepHypothesis::hypo()
{
  // 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;
}

void
TtFullLepHypothesis::setCandidate(const edm::Handle<std::vector<pat::Jet> >& handle, const int& idx, reco::ShallowClonePtrCandidate*& clone, const std::string& correctionLevel)
{
  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() );
}