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/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 to determine the candidate (hypothesis cklass). The buildKey and the 
   buildHypo class have to implemented by derived classes.
**/

class TtSemiLepHypothesis : public edm::EDProducer {

 public:
  explicit TtSemiLepHypothesis(const edm::ParameterSet&);
  ~TtSemiLepHypothesis();

 protected:
  virtual void produce(edm::Event&, const edm::EventSetup&);
  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);
  void setNeutrino(const edm::Handle<std::vector<pat::MET> >& met, const edm::Handle<edm::View<reco::RecoCandidate> >& leps, const int& idx, const int& type);
  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::InputTag jets_;
  edm::InputTag leps_;
  edm::InputTag mets_;
  edm::InputTag match_;
  std::string jetCorrectionLevel_;
  int key_;
  int numberOfRealNeutrinoSolutions_;
  reco::ShallowClonePtrCandidate *lightQ_;
  reco::ShallowClonePtrCandidate *lightQBar_;
  reco::ShallowClonePtrCandidate *hadronicB_;
  reco::ShallowClonePtrCandidate *leptonicB_;
  reco::ShallowClonePtrCandidate *neutrino_;
  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>
void
TtSemiLepHypothesis::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