TtFullHadHypothesis.h

Go to the documentation of this file.

#ifndef TtFullHadHypothesis_h
#define TtFullHadHypothesis_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/Candidate/interface/ShallowClonePtrCandidate.h"

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

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

   \brief   Interface class for the creation of full-hadronic ttbar event hypotheses

   The class provides an interface for the creation of full-hadronic 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 to determine the candidate (hypothesis cklass). The buildKey and the
   buildHypo class have to implemented by derived classes.
**/

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

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);
  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());
  };

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

  virtual void buildKey() = 0;
  virtual void buildHypo(edm::Event& event,
                         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<std::vector<std::vector<int> > > matchToken_;
  std::string jetCorrectionLevel_;
  int key_;
  std::unique_ptr<reco::ShallowClonePtrCandidate> lightQ_;
  std::unique_ptr<reco::ShallowClonePtrCandidate> lightQBar_;
  std::unique_ptr<reco::ShallowClonePtrCandidate> b_;
  std::unique_ptr<reco::ShallowClonePtrCandidate> bBar_;
  std::unique_ptr<reco::ShallowClonePtrCandidate> lightP_;
  std::unique_ptr<reco::ShallowClonePtrCandidate> lightPBar_;
};

// 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> TtFullHadHypothesis::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