TtFullLepHypothesis.h

Go to the documentation of this file.

#ifndef TtFullLepHypothesis_h
#define TtFullLepHypothesis_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 "FWCore/MessageLogger/interface/MessageLogger.h"

#include "DataFormats/PatCandidates/interface/Electron.h"
#include "DataFormats/PatCandidates/interface/Muon.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/TtFullLeptonicEvent.h"

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

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

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

class TtFullLepHypothesis : public edm::EDProducer {

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

 protected:
  virtual void produce(edm::Event&, const edm::EventSetup&);
  void resetCandidates();
  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& evt,
             const edm::Handle<std::vector<pat::Electron > >& elecs, 
             const edm::Handle<std::vector<pat::Muon> >& mus, 
             const edm::Handle<std::vector<pat::Jet> >& jets, 
             const edm::Handle<std::vector<pat::MET> >& mets, 
             std::vector<int>& match,
             const unsigned int iComb) = 0;

 protected:
  bool getMatch_;
  edm::InputTag match_;
  edm::InputTag elecs_;
  edm::InputTag mus_;
  edm::InputTag jets_;
  edm::InputTag mets_;
  std::string jetCorrectionLevel_;
  int key_;
  reco::ShallowClonePtrCandidate *lepton_;
  reco::ShallowClonePtrCandidate *leptonBar_;
  reco::ShallowClonePtrCandidate *b_;
  reco::ShallowClonePtrCandidate *bBar_;
  reco::ShallowClonePtrCandidate *neutrino_;
  reco::ShallowClonePtrCandidate *neutrinoBar_;
  //reco::ShallowClonePtrCandidate *met_;
  
  reco::LeafCandidate* recNu;
  reco::LeafCandidate* recNuBar;    
};

// unfortunately this 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
TtFullLepHypothesis::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