/data/refman/pasoursint/CMSSW_5_3_0/src/AnalysisDataFormats/TopObjects/interface/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;

 protected:
   struct HypoClassKeyStringToEnum { const char* label; HypoClassKey value; };
   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; };
  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;

  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, HypoCombPair hyp) { evtHyp_[key].push_back(hyp); };
  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::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