TtSemiLepHypothesis.h

Go to the documentation of this file.

#ifndef TtSemiLepHypothesis_h
#define TtSemiLepHypothesis_h

#include <memory>
#include <vector>

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "DataFormats/PatCandidates/interface/Jet.h"
#include "DataFormats/PatCandidates/interface/MET.h"
#include "DataFormats/RecoCandidate/interface/RecoCandidate.h"
#include "DataFormats/Candidate/interface/ShallowClonePtrCandidate.h"

#include "AnalysisDataFormats/TopObjects/interface/TtSemiLeptonicEvent.h"

/*
   \class   TtSemiLepHypothesis TtSemiLepHypothesis.h "TopQuarkAnalysis/TopJetCombination/interface/TtSemiLepHypothesis.h"

   \brief   Interface class for the creation of semi-leptonic ttbar event hypotheses

   The class provides an interface for the creation of semi-leptonic ttbar event hypotheses. Input information is read
   from the event content and the proper candidate creation is taken care of. Hypotheses are characterized by the
   CompositeCandidate made of a ttbar pair (including all its decay products in a parton level interpretation) and an
   enumerator type key to specify the algorithm that was used to determine the candidate (the "hypothesis class").
   The buildKey and the buildHypo methods have to implemented by derived classes.
**/

class TtSemiLepHypothesis : public edm::stream::EDProducer<> {
public:
  explicit TtSemiLepHypothesis(const edm::ParameterSet&);

protected:
  void produce(edm::Event&, const edm::EventSetup&) override;
  void resetCandidates();
  std::string jetCorrectionLevel(const std::string& quarkType);
  template <typename C>
  std::unique_ptr<reco::ShallowClonePtrCandidate> makeCandidate(const edm::Handle<C>& handle, const int& idx);
  std::unique_ptr<reco::ShallowClonePtrCandidate> makeCandidate(const edm::Handle<std::vector<pat::Jet> >& handle,
                                                                const int& idx,
                                                                const std::string& correctionLevel);
  void setNeutrino(const edm::Handle<std::vector<pat::MET> >& met,
                   const edm::Handle<edm::View<reco::RecoCandidate> >& leps,
                   const int& idx,
                   const int& type);
  void buildHypo(const edm::Handle<edm::View<reco::RecoCandidate> >& leps,
                 const edm::Handle<std::vector<pat::MET> >& mets,
                 const edm::Handle<std::vector<pat::Jet> >& jets,
                 std::vector<int>& jetPartonAssociation);
  int key() const { return key_; };
  reco::CompositeCandidate hypo();
  bool isValid(const int& idx, const edm::Handle<std::vector<pat::Jet> >& jets) {
    return (0 <= idx && idx < (int)jets->size());
  };
  WDecay::LeptonType leptonType(const reco::RecoCandidate* cand);

  // -----------------------------------------
  // implemet the following two functions
  // for a concrete event hypothesis
  // -----------------------------------------

  virtual void buildKey() = 0;
  virtual void buildHypo(edm::Event& event,
                         const edm::Handle<edm::View<reco::RecoCandidate> >& lepton,
                         const edm::Handle<std::vector<pat::MET> >& neutrino,
                         const edm::Handle<std::vector<pat::Jet> >& jets,
                         std::vector<int>& jetPartonAssociation,
                         const unsigned int iComb) = 0;

protected:
  bool getMatch_;
  edm::EDGetTokenT<std::vector<pat::Jet> > jetsToken_;
  edm::EDGetTokenT<edm::View<reco::RecoCandidate> > lepsToken_;
  edm::EDGetTokenT<std::vector<pat::MET> > metsToken_;
  edm::EDGetTokenT<std::vector<std::vector<int> > > matchToken_;
  edm::EDGetTokenT<int> nJetsConsideredToken_;
  std::string jetCorrectionLevel_;
  int key_;
  int neutrinoSolutionType_;
  int numberOfRealNeutrinoSolutions_;
  std::unique_ptr<reco::ShallowClonePtrCandidate> lightQ_;
  std::unique_ptr<reco::ShallowClonePtrCandidate> lightQBar_;
  std::unique_ptr<reco::ShallowClonePtrCandidate> hadronicB_;
  std::unique_ptr<reco::ShallowClonePtrCandidate> leptonicB_;
  std::unique_ptr<reco::ShallowClonePtrCandidate> neutrino_;
  std::unique_ptr<reco::ShallowClonePtrCandidate> lepton_;
};

// has to be placed in the header since otherwise the function template
// would cause unresolved references in classes derived from this base class
template <typename C>
std::unique_ptr<reco::ShallowClonePtrCandidate> TtSemiLepHypothesis::makeCandidate(const edm::Handle<C>& handle,
                                                                                   const int& idx) {
  typedef typename C::value_type O;
  edm::Ptr<O> ptr = edm::Ptr<O>(handle, idx);
  return std::make_unique<reco::ShallowClonePtrCandidate>(ptr, ptr->charge(), ptr->p4(), ptr->vertex());
}

#endif