SeedingTrackInfoBuilder.cc

Go to the documentation of this file.

#include "RecoBTag/FeatureTools/interface/SeedingTrackInfoBuilder.h"
#include "DataFormats/GeometrySurface/interface/Line.h"
#include "TrackingTools/Records/interface/TransientTrackRecord.h"
#include "TrackingTools/IPTools/interface/IPTools.h"
#include "TrackingTools/PatternTools/interface/TwoTrackMinimumDistance.h"
#include "FWCore/Utilities/interface/isFinite.h"
#include "RecoBTag/TrackProbability/interface/HistogramProbabilityEstimator.h"
 
namespace btagbtvdeep {
 
  SeedingTrackInfoBuilder::SeedingTrackInfoBuilder()
      : pt_(0),
        eta_(0),
        phi_(0),
        mass_(0),
        dz_(0),
        dxy_(0),
        ip3D_(0),
        sip3D_(0),
        ip2D_(0),
        sip2D_(0),
        ip3D_signed_(0),
        sip3D_signed_(0),
        ip2D_signed_(0),
        sip2D_signed_(0),
        chi2reduced_(0),
        nPixelHits_(0),
        nHits_(0),
        jetAxisDistance_(0),
        jetAxisDlength_(0),
        trackProbability3D_(0),
        trackProbability2D_(0) {}
 
  void SeedingTrackInfoBuilder::buildSeedingTrackInfo(const reco::TransientTrack* it,
                                                      const reco::Vertex& pv,
                                                      const reco::Jet& jet, /*GlobalVector jetdirection,*/
                                                      float mass,
                                                      const std::pair<bool, Measurement1D>& ip,
                                                      const std::pair<bool, Measurement1D>& ip2d,
                                                      float jet_distance,
                                                      float jaxis_dlength,
                                                      HistogramProbabilityEstimator* m_probabilityEstimator,
                                                      bool m_computeProbabilities = false) {
    GlobalPoint pvp(pv.x(), pv.y(), pv.z());
    GlobalVector jetdirection(jet.px(), jet.py(), jet.pz());
 
    auto const& aTrack = it->track();
 
    pt_ = aTrack.pt();
    eta_ = aTrack.eta();
    phi_ = aTrack.phi();
    dz_ = aTrack.dz(pv.position());
    dxy_ = aTrack.dxy(pv.position());
    mass_ = mass;
 
    std::pair<bool, Measurement1D> ipSigned = IPTools::signedImpactParameter3D(*it, jetdirection, pv);
    std::pair<bool, Measurement1D> ip2dSigned = IPTools::signedTransverseImpactParameter(*it, jetdirection, pv);
 
    ip3D_ = ip.second.value();
    sip3D_ = ip.second.significance();
    ip2D_ = ip2d.second.value();
    sip2D_ = ip2d.second.significance();
    ip3D_signed_ = ipSigned.second.value();
    sip3D_signed_ = ipSigned.second.significance();
    ip2D_signed_ = ip2dSigned.second.value();
    sip2D_signed_ = ip2dSigned.second.significance();
 
    chi2reduced_ = aTrack.normalizedChi2();
    nPixelHits_ = aTrack.hitPattern().numberOfValidPixelHits();
    nHits_ = aTrack.hitPattern().numberOfValidHits();
 
    jetAxisDistance_ = std::fabs(jet_distance);
    jetAxisDlength_ = jaxis_dlength;
 
    trackProbability3D_ = 0.5;
    trackProbability2D_ = 0.5;
 
    if (m_computeProbabilities) {
      //probability with 3D ip
      std::pair<bool, double> probability =
          m_probabilityEstimator->probability(false, 0, ip.second.significance(), aTrack, jet, pv);
      double prob3D = (probability.first ? probability.second : -1.);
 
      //probability with 2D ip
      probability = m_probabilityEstimator->probability(false, 1, ip2d.second.significance(), aTrack, jet, pv);
      double prob2D = (probability.first ? probability.second : -1.);
 
      trackProbability3D_ = prob3D;
      trackProbability2D_ = prob2D;
    }
 
    if (!edm::isFinite(trackProbability3D_))
      trackProbability3D_ = 0.5;
    if (!edm::isFinite(trackProbability2D_))
      trackProbability2D_ = 0.5;
  }
 
}  // namespace btagbtvdeep