BPHDecayVertex.cc

Go to the documentation of this file.

/*
 *  See header file for a description of this class.
 *
 *  \author Paolo Ronchese INFN Padova
 *
 */

//-----------------------
// This Class' Header --
//-----------------------
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHDecayVertex.h"

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoCandidate.h"
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoBuilder.h"
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHTrackReference.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
#include "TrackingTools/TransientTrack/interface/TransientTrack.h"
#include "TrackingTools/Records/interface/TransientTrackRecord.h"
#include "RecoVertex/VertexPrimitives/interface/TransientVertex.h"
#include "RecoVertex/KalmanVertexFit/interface/KalmanVertexFitter.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

//---------------
// C++ Headers --
//---------------
#include <iostream>

using namespace std;

//-------------------
// Initializations --
//-------------------

//----------------
// Constructors --
//----------------
BPHDecayVertex::BPHDecayVertex(const edm::EventSetup* es)
    : evSetup(es), oldTracks(true), oldVertex(true), validTks(false) {}

BPHDecayVertex::BPHDecayVertex(const BPHDecayVertex* ptr, const edm::EventSetup* es)
    : evSetup(es), oldTracks(true), oldVertex(true), validTks(false) {
  map<const reco::Candidate*, const reco::Candidate*> iMap;
  const vector<const reco::Candidate*>& daug = daughters();
  const vector<Component>& list = ptr->componentList();
  int i;
  int n = daug.size();
  for (i = 0; i < n; ++i) {
    const reco::Candidate* cand = daug[i];
    iMap[originalReco(cand)] = cand;
  }
  for (i = 0; i < n; ++i) {
    const Component& c = list[i];
    searchMap[iMap[c.cand]] = c.searchList;
  }
  const vector<BPHRecoConstCandPtr>& dComp = daughComp();
  int j;
  int m = dComp.size();
  for (j = 0; j < m; ++j) {
    const map<const reco::Candidate*, string>& dMap = dComp[j]->searchMap;
    searchMap.insert(dMap.begin(), dMap.end());
  }
}

//--------------
// Destructor --
//--------------
BPHDecayVertex::~BPHDecayVertex() {}

//--------------
// Operations --
//--------------
bool BPHDecayVertex::validTracks() const {
  if (oldVertex)
    fitVertex();
  return validTks;
}

bool BPHDecayVertex::validVertex() const {
  if (oldVertex)
    fitVertex();
  return validTks && fittedVertex.isValid();
}

const reco::Vertex& BPHDecayVertex::vertex() const {
  if (oldVertex)
    fitVertex();
  return fittedVertex;
}

const vector<const reco::Track*>& BPHDecayVertex::tracks() const {
  if (oldTracks)
    tTracks();
  return rTracks;
}

const reco::Track* BPHDecayVertex::getTrack(const reco::Candidate* cand) const {
  if (oldTracks)
    tTracks();
  map<const reco::Candidate*, const reco::Track*>::const_iterator iter = tkMap.find(cand);
  map<const reco::Candidate*, const reco::Track*>::const_iterator iend = tkMap.end();
  return (iter != iend ? iter->second : nullptr);
}

const vector<reco::TransientTrack>& BPHDecayVertex::transientTracks() const {
  if (oldTracks)
    tTracks();
  return trTracks;
}

reco::TransientTrack* BPHDecayVertex::getTransientTrack(const reco::Candidate* cand) const {
  if (oldTracks)
    tTracks();
  map<const reco::Candidate*, reco::TransientTrack*>::const_iterator iter = ttMap.find(cand);
  map<const reco::Candidate*, reco::TransientTrack*>::const_iterator iend = ttMap.end();
  return (iter != iend ? iter->second : nullptr);
}

const string& BPHDecayVertex::getTrackSearchList(const reco::Candidate* cand) const {
  static string dum = "";
  map<const reco::Candidate*, string>::const_iterator iter = searchMap.find(cand);
  if (iter != searchMap.end())
    return iter->second;
  return dum;
}

void BPHDecayVertex::addV(const string& name, const reco::Candidate* daug, const string& searchList, double mass) {
  addP(name, daug, mass);
  searchMap[daughters().back()] = searchList;
  return;
}

void BPHDecayVertex::addV(const string& name, const BPHRecoConstCandPtr& comp) {
  addP(name, comp);
  const map<const reco::Candidate*, string>& dMap = comp->searchMap;
  searchMap.insert(dMap.begin(), dMap.end());
  return;
}

void BPHDecayVertex::setNotUpdated() const {
  BPHDecayMomentum::setNotUpdated();
  oldTracks = oldVertex = true;
  validTks = false;
  return;
}

void BPHDecayVertex::tTracks() const {
  oldTracks = false;
  rTracks.clear();
  trTracks.clear();
  tkMap.clear();
  ttMap.clear();
  edm::ESHandle<TransientTrackBuilder> ttB;
  evSetup->get<TransientTrackRecord>().get("TransientTrackBuilder", ttB);
  const vector<const reco::Candidate*>& dL = daughFull();
  int n = dL.size();
  trTracks.reserve(n);
  validTks = true;
  while (n--) {
    const reco::Candidate* rp = dL[n];
    tkMap[rp] = nullptr;
    ttMap[rp] = nullptr;
    if (!rp->charge())
      continue;
    const reco::Track* tp;
    const char* searchList = "cfhp";
    map<const reco::Candidate*, string>::const_iterator iter = searchMap.find(rp);
    if (iter != searchMap.end())
      searchList = iter->second.c_str();
    tp = BPHTrackReference::getTrack(*rp, searchList);
    if (tp == nullptr) {
      edm::LogPrint("DataNotFound") << "BPHDecayVertex::tTracks: "
                                    << "no track for reco::(PF)Candidate";
      validTks = false;
      continue;
    }
    rTracks.push_back(tp);
    trTracks.push_back(ttB->build(tp));
    reco::TransientTrack* ttp = &trTracks.back();
    tkMap[rp] = tp;
    ttMap[rp] = ttp;
  }
  return;
}

void BPHDecayVertex::fitVertex() const {
  oldVertex = false;
  if (oldTracks)
    tTracks();
  if (trTracks.size() < 2)
    return;
  KalmanVertexFitter kvf(true);
  TransientVertex tv = kvf.vertex(trTracks);
  fittedVertex = tv;
  return;
}