TtFullHadHypothesis.cc

Go to the documentation of this file.

#include "CommonTools/CandUtils/interface/AddFourMomenta.h"
#include "TopQuarkAnalysis/TopJetCombination/interface/TtFullHadHypothesis.h"
 
TtFullHadHypothesis::TtFullHadHypothesis(const edm::ParameterSet& cfg)
    : jetsToken_(consumes<std::vector<pat::Jet> >(cfg.getParameter<edm::InputTag>("jets"))),
      lightQ_(nullptr),
      lightQBar_(nullptr),
      b_(nullptr),
      bBar_(nullptr),
      lightP_(nullptr),
      lightPBar_(nullptr) {
  getMatch_ = false;
  if (cfg.exists("match")) {
    getMatch_ = true;
    matchToken_ = consumes<std::vector<std::vector<int> > >(cfg.getParameter<edm::InputTag>("match"));
  }
  if (cfg.exists("jetCorrectionLevel")) {
    jetCorrectionLevel_ = cfg.getParameter<std::string>("jetCorrectionLevel");
  }
  produces<std::vector<std::pair<reco::CompositeCandidate, std::vector<int> > > >();
  produces<int>("Key");
}
 
TtFullHadHypothesis::~TtFullHadHypothesis() {
  if (lightQ_)
    delete lightQ_;
  if (lightQBar_)
    delete lightQBar_;
  if (b_)
    delete b_;
  if (bBar_)
    delete bBar_;
  if (lightP_)
    delete lightP_;
  if (lightPBar_)
    delete lightPBar_;
}
 
void TtFullHadHypothesis::produce(edm::Event& evt, const edm::EventSetup& setup) {
  edm::Handle<std::vector<pat::Jet> > jets;
  evt.getByToken(jetsToken_, jets);
 
  std::vector<std::vector<int> > matchVec;
  if (getMatch_) {
    edm::Handle<std::vector<std::vector<int> > > matchHandle;
    evt.getByToken(matchToken_, matchHandle);
    matchVec = *matchHandle;
  } else {
    std::vector<int> dummyMatch;
    for (unsigned int i = 0; i < 4; ++i)
      dummyMatch.push_back(-1);
    matchVec.push_back(dummyMatch);
  }
 
  // declare unique_ptr for products
  std::unique_ptr<std::vector<std::pair<reco::CompositeCandidate, std::vector<int> > > > pOut(
      new std::vector<std::pair<reco::CompositeCandidate, std::vector<int> > >);
  std::unique_ptr<int> pKey(new int);
 
  // go through given vector of jet combinations
  unsigned int idMatch = 0;
  typedef std::vector<std::vector<int> >::iterator MatchVecIterator;
  for (MatchVecIterator match = matchVec.begin(); match != matchVec.end(); ++match) {
    // reset pointers
    resetCandidates();
    // build hypothesis
    buildHypo(evt, jets, *match, idMatch++);
    pOut->push_back(std::make_pair(hypo(), *match));
  }
  // feed out hyps and matches
  evt.put(std::move(pOut));
 
  // build and feed out key
  buildKey();
  *pKey = key();
  evt.put(std::move(pKey), "Key");
}
 
void TtFullHadHypothesis::resetCandidates() {
  lightQ_ = nullptr;
  lightQBar_ = nullptr;
  b_ = nullptr;
  bBar_ = nullptr;
  lightP_ = nullptr;
  lightPBar_ = nullptr;
}
 
reco::CompositeCandidate TtFullHadHypothesis::hypo() {
  // check for sanity of the hypothesis
  if (!lightQ_ || !lightQBar_ || !b_ || !bBar_ || !lightP_ || !lightPBar_)
    return reco::CompositeCandidate();
 
  // setup transient references
  reco::CompositeCandidate hyp, top, w, topBar, wBar;
 
  AddFourMomenta addFourMomenta;
  // build up the top bar branch
  wBar.addDaughter(*lightP_, TtFullHadDaughter::LightP);
  wBar.addDaughter(*lightPBar_, TtFullHadDaughter::LightPBar);
  addFourMomenta.set(wBar);
  topBar.addDaughter(wBar, TtFullHadDaughter::WMinus);
  topBar.addDaughter(*bBar_, TtFullHadDaughter::BBar);
  addFourMomenta.set(topBar);
 
  // build up the top branch that decays hadronically
  w.addDaughter(*lightQ_, TtFullHadDaughter::LightQ);
  w.addDaughter(*lightQBar_, TtFullHadDaughter::LightQBar);
  addFourMomenta.set(w);
  top.addDaughter(w, TtFullHadDaughter::WPlus);
  top.addDaughter(*b_, TtFullHadDaughter::B);
  addFourMomenta.set(top);
 
  // build ttbar hypotheses
  hyp.addDaughter(topBar, TtFullHadDaughter::TopBar);
  hyp.addDaughter(top, TtFullHadDaughter::Top);
  addFourMomenta.set(hyp);
 
  return hyp;
}
 
std::string TtFullHadHypothesis::jetCorrectionLevel(const std::string& quarkType) {
  // jetCorrectionLevel was not configured
  if (jetCorrectionLevel_.empty())
    throw cms::Exception("Configuration")
        << "Unconfigured jetCorrectionLevel. Please use an appropriate, non-empty string.\n";
 
  // quarkType is unknown
  if (!(quarkType == "wQuarkMix" || quarkType == "udsQuark" || quarkType == "cQuark" || quarkType == "bQuark"))
    throw cms::Exception("Configuration") << quarkType << " is unknown as a quarkType for the jetCorrectionLevel.\n";
 
  // combine correction level; start with a ':' even if
  // there is no flavor tag to be added, as it is needed
  // by setCandidate to disentangle the correction tag
  // from a potential flavor tag, which can be empty
  std::string level = jetCorrectionLevel_ + ":";
  if (level == "L5Flavor:" || level == "L6UE:" || level == "L7Parton:") {
    if (quarkType == "wQuarkMix") {
      level += "wMix";
    }
    if (quarkType == "udsQuark") {
      level += "uds";
    }
    if (quarkType == "cQuark") {
      level += "charm";
    }
    if (quarkType == "bQuark") {
      level += "bottom";
    }
  } else {
    level += "none";
  }
  return level;
}
 
void TtFullHadHypothesis::setCandidate(const edm::Handle<std::vector<pat::Jet> >& handle,
                                       const int& idx,
                                       reco::ShallowClonePtrCandidate*& clone,
                                       const std::string& correctionLevel) {
  edm::Ptr<pat::Jet> ptr = edm::Ptr<pat::Jet>(handle, idx);
  // disentangle the correction from the potential flavor tag
  // by the separating ':'; the flavor tag can be empty though
  std::string step = correctionLevel.substr(0, correctionLevel.find(":"));
  std::string flavor = correctionLevel.substr(1 + correctionLevel.find(":"));
  float corrFactor = 1.;
  if (flavor == "wMix")
    corrFactor = 0.75 * ptr->jecFactor(step, "uds") + 0.25 * ptr->jecFactor(step, "charm");
  else
    corrFactor = ptr->jecFactor(step, flavor);
  clone = new reco::ShallowClonePtrCandidate(ptr, ptr->charge(), ptr->p4() * corrFactor, ptr->vertex());
}