TtEvent.h

Go to the documentation of this file.

#ifndef TopObjects_TtEvent_h
#define TopObjects_TtEvent_h
 
#include <vector>
#include <string>
 
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/RefProd.h"
#include "DataFormats/Candidate/interface/CompositeCandidate.h"
#include "AnalysisDataFormats/TopObjects/interface/TtGenEvent.h"
 
namespace edm {
  class LogInfo;
}
 
class TtEvent {
public:
  enum HypoClassKey {
    kGeom,
    kWMassMaxSumPt,
    kMaxSumPtWMass,
    kGenMatch,
    kMVADisc,
    kKinFit,
    kKinSolution,
    kWMassDeltaTopMass,
    kHitFit
  };
  typedef std::pair<reco::CompositeCandidate, std::vector<int> > HypoCombPair;
  struct HypoClassKeyStringToEnum {
    const char* label;
    HypoClassKey value;
  };
 
protected:
  HypoClassKey hypoClassKeyFromString(const std::string& label) const;
 
public:
  TtEvent(){};
  virtual ~TtEvent(){};
 
  std::pair<WDecay::LeptonType, WDecay::LeptonType> lepDecays() const { return lepDecays_; }
  const reco::CompositeCandidate& eventHypo(const HypoClassKey& key, const unsigned& cmb = 0) const {
    return (evtHyp_.find(key)->second)[cmb].first;
  };
  const edm::RefProd<TtGenEvent>& genEvent() const { return genEvt_; };
 
  bool isHypoClassAvailable(const std::string& key) const { return isHypoClassAvailable(hypoClassKeyFromString(key)); };
  bool isHypoClassAvailable(const HypoClassKey& key) const { return (evtHyp_.find(key) != evtHyp_.end()); };
  // check if hypothesis 'cmb' is available within the hypothesis class
  bool isHypoAvailable(const std::string& key, const unsigned& cmb = 0) const {
    return isHypoAvailable(hypoClassKeyFromString(key), cmb);
  };
  bool isHypoAvailable(const HypoClassKey& key, const unsigned& cmb = 0) const {
    return isHypoClassAvailable(key) ? (cmb < evtHyp_.find(key)->second.size()) : false;
  };
  bool isHypoValid(const std::string& key, const unsigned& cmb = 0) const {
    return isHypoValid(hypoClassKeyFromString(key), cmb);
  };
  bool isHypoValid(const HypoClassKey& key, const unsigned& cmb = 0) const {
    return isHypoAvailable(key, cmb) ? !eventHypo(key, cmb).roles().empty() : false;
  };
  unsigned int numberOfAvailableHypoClasses() const { return evtHyp_.size(); };
  unsigned int numberOfAvailableHypos(const std::string& key) const {
    return numberOfAvailableHypos(hypoClassKeyFromString(key));
  };
  unsigned int numberOfAvailableHypos(const HypoClassKey& key) const {
    return isHypoAvailable(key) ? evtHyp_.find(key)->second.size() : 0;
  };
  int numberOfConsideredJets(const std::string& key) const {
    return numberOfConsideredJets(hypoClassKeyFromString(key));
  };
  int numberOfConsideredJets(const HypoClassKey& key) const {
    return (isHypoAvailable(key) ? nJetsConsidered_.find(key)->second : -1);
  };
  std::vector<int> jetLeptonCombination(const std::string& key, const unsigned& cmb = 0) const {
    return jetLeptonCombination(hypoClassKeyFromString(key), cmb);
  };
  std::vector<int> jetLeptonCombination(const HypoClassKey& key, const unsigned& cmb = 0) const {
    return (evtHyp_.find(key)->second)[cmb].second;
  };
  double genMatchSumPt(const unsigned& cmb = 0) const {
    return (cmb < genMatchSumPt_.size() ? genMatchSumPt_[cmb] : -1.);
  };
  double genMatchSumDR(const unsigned& cmb = 0) const {
    return (cmb < genMatchSumDR_.size() ? genMatchSumDR_[cmb] : -1.);
  };
  std::string mvaMethod() const { return mvaMethod_; }
  double mvaDisc(const unsigned& cmb = 0) const { return (cmb < mvaDisc_.size() ? mvaDisc_[cmb] : -1.); }
  double fitChi2(const unsigned& cmb = 0) const { return (cmb < fitChi2_.size() ? fitChi2_[cmb] : -1.); }
  double hitFitChi2(const unsigned& cmb = 0) const { return (cmb < hitFitChi2_.size() ? hitFitChi2_[cmb] : -1.); }
  double fitProb(const unsigned& cmb = 0) const { return (cmb < fitProb_.size() ? fitProb_[cmb] : -1.); }
  double hitFitProb(const unsigned& cmb = 0) const { return (cmb < hitFitProb_.size() ? hitFitProb_[cmb] : -1.); }
  double hitFitMT(const unsigned& cmb = 0) const { return (cmb < hitFitMT_.size() ? hitFitMT_[cmb] : -1.); }
  double hitFitSigMT(const unsigned& cmb = 0) const { return (cmb < hitFitSigMT_.size() ? hitFitSigMT_[cmb] : -1.); }
  int correspondingHypo(const std::string& key1, const unsigned& hyp1, const std::string& key2) const {
    return correspondingHypo(hypoClassKeyFromString(key1), hyp1, hypoClassKeyFromString(key2));
  };
  int correspondingHypo(const HypoClassKey& key1, const unsigned& hyp1, const HypoClassKey& key2) const;
 
  const reco::Candidate* topPair(const std::string& key, const unsigned& cmb = 0) const {
    return topPair(hypoClassKeyFromString(key), cmb);
  };
  const reco::Candidate* topPair(const HypoClassKey& key, const unsigned& cmb = 0) const {
    return !isHypoValid(key, cmb) ? nullptr : (reco::Candidate*)&eventHypo(key, cmb);
  };
  const math::XYZTLorentzVector* topPair() const { return (!genEvt_ ? nullptr : this->genEvent()->topPair()); };
 
  void printParticle(edm::LogInfo& log, const char* name, const reco::Candidate* cand) const;
 
  void setLepDecays(const WDecay::LeptonType& lepDecTop1, const WDecay::LeptonType& lepDecTop2) {
    lepDecays_ = std::make_pair(lepDecTop1, lepDecTop2);
  };
  void setGenEvent(const edm::Handle<TtGenEvent>& evt) { genEvt_ = edm::RefProd<TtGenEvent>(evt); };
  void addEventHypo(const HypoClassKey& key, const HypoCombPair& hyp) { evtHyp_[key].push_back(hyp); };
  void setNumberOfConsideredJets(const HypoClassKey& key, const unsigned int nJets) { nJetsConsidered_[key] = nJets; };
  void setGenMatchSumPt(const std::vector<double>& val) { genMatchSumPt_ = val; };
  void setGenMatchSumDR(const std::vector<double>& val) { genMatchSumDR_ = val; };
  void setMvaMethod(const std::string& name) { mvaMethod_ = name; };
  void setMvaDiscriminators(const std::vector<double>& val) { mvaDisc_ = val; };
  void setFitChi2(const std::vector<double>& val) { fitChi2_ = val; };
  void setHitFitChi2(const std::vector<double>& val) { hitFitChi2_ = val; };
  void setFitProb(const std::vector<double>& val) { fitProb_ = val; };
  void setHitFitProb(const std::vector<double>& val) { hitFitProb_ = val; };
  void setHitFitMT(const std::vector<double>& val) { hitFitMT_ = val; };
  void setHitFitSigMT(const std::vector<double>& val) { hitFitSigMT_ = val; };
 
protected:
  std::pair<WDecay::LeptonType, WDecay::LeptonType> lepDecays_;
  edm::RefProd<TtGenEvent> genEvt_;
  std::map<HypoClassKey, std::vector<HypoCombPair> > evtHyp_;
  std::map<HypoClassKey, int> nJetsConsidered_;
 
  std::vector<double> fitChi2_;
  std::vector<double> hitFitChi2_;
  std::vector<double> fitProb_;
  std::vector<double> hitFitProb_;
  std::vector<double> hitFitMT_;
  std::vector<double> hitFitSigMT_;
  std::vector<double> genMatchSumPt_;
  std::vector<double> genMatchSumDR_;
  std::string mvaMethod_;
  std::vector<double> mvaDisc_;
};
 
#endif