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/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::EDProducer {
public:
  explicit TtFullHadHypothesis(const edm::ParameterSet& cfg);
  ~TtFullHadHypothesis() override;
 
protected:
  void produce(edm::Event&, const edm::EventSetup&) override;
  void resetCandidates();
  std::string jetCorrectionLevel(const std::string& quarkType);
  template <typename C>
  void setCandidate(const edm::Handle<C>& handle, const int& idx, reco::ShallowClonePtrCandidate*& clone);
  void setCandidate(const edm::Handle<std::vector<pat::Jet> >& handle,
                    const int& idx,
                    reco::ShallowClonePtrCandidate*& clone,
                    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_;
  reco::ShallowClonePtrCandidate* lightQ_;
  reco::ShallowClonePtrCandidate* lightQBar_;
  reco::ShallowClonePtrCandidate* b_;
  reco::ShallowClonePtrCandidate* bBar_;
  reco::ShallowClonePtrCandidate* lightP_;
  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>
void TtFullHadHypothesis::setCandidate(const edm::Handle<C>& handle,
                                       const int& idx,
                                       reco::ShallowClonePtrCandidate*& clone) {
  typedef typename C::value_type O;
  edm::Ptr<O> ptr = edm::Ptr<O>(handle, idx);
  clone = new reco::ShallowClonePtrCandidate(ptr, ptr->charge(), ptr->p4(), ptr->vertex());
}
#endif