d3/dea/GhostTrackComputer_8cc_source.html

 #include <iostream>
 #include <cstddef>
 #include <string>
 #include <cmath>
 #include <vector>

 #include <Math/VectorUtil.h>

 #include "FWCore/Utilities/interface/Exception.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"

 #include "DataFormats/Math/interface/Vector3D.h"
 #include "DataFormats/Math/interface/LorentzVector.h"
 #include "DataFormats/GeometryCommonDetAlgo/interface/Measurement1D.h"
 #include "DataFormats/GeometryVector/interface/GlobalPoint.h"
 #include "DataFormats/GeometryVector/interface/GlobalVector.h"
 #include "DataFormats/GeometryVector/interface/VectorUtil.h"
 #include "DataFormats/TrackReco/interface/Track.h"
 #include "DataFormats/TrackReco/interface/TrackFwd.h"
 #include "DataFormats/BTauReco/interface/TrackIPTagInfo.h"
 #include "DataFormats/BTauReco/interface/SecondaryVertexTagInfo.h"
 #include "DataFormats/BTauReco/interface/TaggingVariable.h"
 #include "DataFormats/BTauReco/interface/VertexTypes.h"
 #include "DataFormats/BTauReco/interface/ParticleMasses.h"

 #include "RecoBTag/SecondaryVertex/interface/TrackSorting.h"
 #include "RecoBTag/SecondaryVertex/interface/TrackSelector.h"
 #include "RecoBTag/SecondaryVertex/interface/TrackKinematics.h"
 #include "RecoBTag/SecondaryVertex/interface/V0Filter.h"

 #include "RecoBTag/SecondaryVertex/interface/GhostTrackComputer.h"

 using namespace reco;

 static edm::ParameterSet dropDeltaR(const edm::ParameterSet &pset)
 {
     edm::ParameterSet psetCopy(pset);
     psetCopy.addParameter<double>("jetDeltaRMax", 99999.0);
     return psetCopy;
 }

 GhostTrackComputer::GhostTrackComputer(const edm::ParameterSet &params) :
     charmCut(params.getParameter<double>("charmCut")),
     sortCriterium(TrackSorting::getCriterium(params.getParameter<std::string>("trackSort"))),
     trackSelector(params.getParameter<edm::ParameterSet>("trackSelection")),
     trackNoDeltaRSelector(dropDeltaR(params.getParameter<edm::ParameterSet>("trackSelection"))),
     minTrackWeight(params.getParameter<double>("minimumTrackWeight")),
     trackPairV0Filter(params.getParameter<edm::ParameterSet>("trackPairV0Filter"))
 {
 }

 const btag::TrackIPData &
 GhostTrackComputer::threshTrack(const TrackIPTagInfo &trackIPTagInfo,
                                 const btag::SortCriteria sort,
                                 const reco::Jet &jet,
                                 const GlobalPoint &pv) const
 {
     const edm::RefVector<TrackCollection> &tracks =
                     trackIPTagInfo.selectedTracks();
     const std::vector<btag::TrackIPData> &ipData =
                     trackIPTagInfo.impactParameterData();
     std::vector<std::size_t> indices = trackIPTagInfo.sortedIndexes(sort);

     TrackKinematics kin;
     for(std::vector<std::size_t>::const_iterator iter = indices.begin();
         iter != indices.end(); ++iter) {
         const btag::TrackIPData &data = ipData[*iter];
         const Track &track = *tracks[*iter];

         if (!trackNoDeltaRSelector(track, data, jet, pv))
             continue;

         kin.add(track);
         if (kin.vectorSum().M() > charmCut)
             return data;
     }

     static const btag::TrackIPData dummy = {
         GlobalPoint(),
         GlobalPoint(),
         Measurement1D(-1.0, 1.0),
         Measurement1D(-1.0, 1.0),
         Measurement1D(-1.0, 1.0),
         Measurement1D(-1.0, 1.0),
         0.
     };
     return dummy;
 }

 const btag::TrackIPData &
 GhostTrackComputer::threshTrack(const CandIPTagInfo &trackIPTagInfo,
                                 const btag::SortCriteria sort,
                                 const reco::Jet &jet,
                                 const GlobalPoint &pv) const
 {
         const CandIPTagInfo::input_container &tracks =
                                         trackIPTagInfo.selectedTracks();
         const std::vector<btag::TrackIPData> &ipData =
                                         trackIPTagInfo.impactParameterData();
         std::vector<std::size_t> indices = trackIPTagInfo.sortedIndexes(sort);

         TrackKinematics kin;
         for(std::vector<std::size_t>::const_iterator iter = indices.begin(); iter != indices.end(); ++iter) {
         const btag::TrackIPData &data = ipData[*iter];
         const CandidatePtr &track = tracks[*iter];

         if (!trackNoDeltaRSelector(track, data, jet, pv))
                continue;

         kin.add(track);
         if (kin.vectorSum().M() > charmCut)
                return data;
         }

         static const btag::TrackIPData dummy = {
                 GlobalPoint(),
                 GlobalPoint(),
                 Measurement1D(-1.0, 1.0),
                 Measurement1D(-1.0, 1.0),
                 Measurement1D(-1.0, 1.0),
                 Measurement1D(-1.0, 1.0),
                 0.
         };
         return dummy;
 }

 static void addMeas(std::pair<double, double> &sum, Measurement1D meas)
 {
     double weight = 1. / meas.error();
     weight *= weight;
     sum.first += weight * meas.value();
     sum.second += weight;
 }

 TaggingVariableList
 GhostTrackComputer::operator () (const TrackIPTagInfo &ipInfo,
                                  const SecondaryVertexTagInfo &svInfo) const
 {
     using namespace ROOT::Math;

     edm::RefToBase<Jet> jet = ipInfo.jet();
     math::XYZVector jetDir = jet->momentum().Unit();
     bool havePv = ipInfo.primaryVertex().isNonnull();
     GlobalPoint pv;
     if (havePv)
         pv = GlobalPoint(ipInfo.primaryVertex()->x(),
                          ipInfo.primaryVertex()->y(),
                          ipInfo.primaryVertex()->z());

     btag::Vertices::VertexType vtxType = btag::Vertices::NoVertex;

     TaggingVariableList vars;

     vars.insert(btau::jetPt, jet->pt(), true);
     vars.insert(btau::jetEta, jet->eta(), true);

     TrackKinematics allKinematics;
     TrackKinematics vertexKinematics;
     TrackKinematics trackKinematics;

     std::pair<double, double> vertexDist2D, vertexDist3D;
     std::pair<double, double> tracksDist2D, tracksDist3D;

     unsigned int nVertices = 0;
     unsigned int nVertexTracks = 0;
     unsigned int nTracks = 0;
     for(unsigned int i = 0; i < svInfo.nVertices(); i++) {
         const Vertex &vertex = svInfo.secondaryVertex(i);
         bool hasRefittedTracks = vertex.hasRefittedTracks();
         TrackRefVector tracks = svInfo.vertexTracks(i);
         unsigned int n = 0;
         for(TrackRefVector::const_iterator track = tracks.begin();
             track != tracks.end(); track++)
             if (svInfo.trackWeight(i, *track) >= minTrackWeight)
                 n++;

         if (n < 1)
             continue;
         bool isTrackVertex = (n == 1);
         ++*(isTrackVertex ? &nTracks : &nVertices);

         addMeas(*(isTrackVertex ? &tracksDist2D : &vertexDist2D),
                     svInfo.flightDistance(i, true));
         addMeas(*(isTrackVertex ? &tracksDist3D : &vertexDist3D),
                     svInfo.flightDistance(i, false));

         TrackKinematics &kin = isTrackVertex ? trackKinematics
                                              : vertexKinematics;
         for(TrackRefVector::const_iterator track = tracks.begin();
             track != tracks.end(); track++) {
             float w = svInfo.trackWeight(i, *track);
             if (w < minTrackWeight)
                 continue;
             if (hasRefittedTracks) {
                 Track actualTrack =
                         vertex.refittedTrack(*track);
                 kin.add(actualTrack, w);
                 vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir,
                         actualTrack.momentum()), true);
             } else {
                 kin.add(**track, w);
                 vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir,
                         (*track)->momentum()), true);
             }
             if (!isTrackVertex)
                 nVertexTracks++;
         }
     }

     Measurement1D dist2D, dist3D;
     if (nVertices) {
         vtxType = btag::Vertices::RecoVertex;

         if (nVertices == 1 && nTracks) {
             vertexDist2D.first += tracksDist2D.first;
             vertexDist2D.second += tracksDist2D.second;
             vertexDist3D.first += tracksDist3D.first;
             vertexDist3D.second += tracksDist3D.second;
             vertexKinematics += trackKinematics;
         }

         dist2D = Measurement1D(
                 vertexDist2D.first / vertexDist2D.second,
                 std::sqrt(1. / vertexDist2D.second));
         dist3D = Measurement1D(
                 vertexDist3D.first / vertexDist3D.second,
                 std::sqrt(1. / vertexDist3D.second));

         vars.insert(btau::jetNSecondaryVertices, nVertices, true);
         vars.insert(btau::vertexNTracks, nVertexTracks, true);
     } else if (nTracks) {
         vtxType = btag::Vertices::PseudoVertex;
         vertexKinematics = trackKinematics;

         dist2D = Measurement1D(
                 tracksDist2D.first / tracksDist2D.second,
                 std::sqrt(1. / tracksDist2D.second));
         dist3D = Measurement1D(
                 tracksDist3D.first / tracksDist3D.second,
                 std::sqrt(1. / tracksDist3D.second));
     }

     if (nVertices || nTracks) {
         vars.insert(btau::flightDistance2dVal, dist2D.value(), true);
         vars.insert(btau::flightDistance2dSig, dist2D.significance(), true);
         vars.insert(btau::flightDistance3dVal, dist3D.value(), true);
         vars.insert(btau::flightDistance3dSig, dist3D.significance(), true);
         vars.insert(btau::vertexJetDeltaR,
                     Geom::deltaR(svInfo.flightDirection(0), jetDir),true);
         vars.insert(btau::jetNSingleTrackVertices, nTracks, true);
     }

     std::vector<std::size_t> indices = ipInfo.sortedIndexes(sortCriterium);
     const std::vector<btag::TrackIPData> &ipData =
                         ipInfo.impactParameterData();
     const edm::RefVector<TrackCollection> &tracks =
                         ipInfo.selectedTracks();

     TrackRef trackPairV0Test[2];
     for(unsigned int i = 0; i < indices.size(); i++) {
         std::size_t idx = indices[i];
         const btag::TrackIPData &data = ipData[idx];
         const TrackRef &trackRef = tracks[idx];
         const Track &track = *trackRef;

         // filter track

         if (!trackSelector(track, data, *jet, pv))
             continue;

         // add track to kinematics for all tracks in jet

         allKinematics.add(track);

         // check against all other tracks for V0 track pairs

         trackPairV0Test[0] = tracks[idx];
         bool ok = true;
         for(unsigned int j = 0; j < indices.size(); j++) {
             if (i == j)
                 continue;

             std::size_t pairIdx = indices[j];
             const btag::TrackIPData &pairTrackData =
                             ipData[pairIdx];
             const TrackRef &pairTrackRef = tracks[pairIdx];
             const Track &pairTrack = *pairTrackRef;

             if (!trackSelector(pairTrack, pairTrackData, *jet, pv))
                 continue;

             trackPairV0Test[1] = pairTrackRef;
             if (!trackPairV0Filter(trackPairV0Test, 2)) {
                 ok = false;
                 break;
             }
         }
         if (!ok)
             continue;

         // add track variables

         math::XYZVector trackMom = track.momentum();
         double trackMag = std::sqrt(trackMom.Mag2());

         vars.insert(btau::trackSip3dVal, data.ip3d.value(), true);
         vars.insert(btau::trackSip3dSig, data.ip3d.significance(), true);
         vars.insert(btau::trackSip2dVal, data.ip2d.value(), true);
         vars.insert(btau::trackSip2dSig, data.ip2d.significance(), true);
         vars.insert(btau::trackJetDistVal, data.distanceToJetAxis.value(), true);
         vars.insert(btau::trackGhostTrackDistVal, data.distanceToGhostTrack.value(), true);
         vars.insert(btau::trackGhostTrackDistSig, data.distanceToGhostTrack.significance(), true);
         vars.insert(btau::trackGhostTrackWeight, data.ghostTrackWeight, true);
         vars.insert(btau::trackDecayLenVal, havePv ? (data.closestToGhostTrack - pv).mag() : -1.0, true);

         vars.insert(btau::trackMomentum, trackMag, true);
         vars.insert(btau::trackEta, trackMom.Eta(), true);

         vars.insert(btau::trackChi2, track.normalizedChi2(), true);
         vars.insert(btau::trackNPixelHits, track.hitPattern().pixelLayersWithMeasurement(), true);
         vars.insert(btau::trackNTotalHits, track.hitPattern().trackerLayersWithMeasurement(), true);
         vars.insert(btau::trackPtRel, VectorUtil::Perp(trackMom, jetDir), true);
         vars.insert(btau::trackDeltaR, VectorUtil::DeltaR(trackMom, jetDir), true);
     }

     vars.insert(btau::vertexCategory, vtxType, true);
     vars.insert(btau::trackSumJetDeltaR,
                 VectorUtil::DeltaR(allKinematics.vectorSum(), jetDir), true);
     vars.insert(btau::trackSumJetEtRatio,
                 allKinematics.vectorSum().Et() / ipInfo.jet()->et(), true);
     vars.insert(btau::trackSip3dSigAboveCharm,
                 threshTrack(ipInfo, reco::btag::IP3DSig, *jet, pv)
                                     .ip3d.significance(),
                 true);
     vars.insert(btau::trackSip2dSigAboveCharm,
                 threshTrack(ipInfo, reco::btag::IP2DSig, *jet, pv)
                                     .ip2d.significance(),
                 true);

     if (vtxType != btag::Vertices::NoVertex) {
         math::XYZTLorentzVector allSum = allKinematics.vectorSum();
         math::XYZTLorentzVector vertexSum = vertexKinematics.vectorSum();

         vars.insert(btau::vertexMass, vertexSum.M(), true);
         if (allKinematics.numberOfTracks())
             vars.insert(btau::vertexEnergyRatio,
                         vertexSum.E() / allSum.E(), true);
         else
             vars.insert(btau::vertexEnergyRatio, 1, true);
     }

     vars.finalize();

     return vars;
 }

 TaggingVariableList
 GhostTrackComputer::operator () (const CandIPTagInfo &ipInfo,
                                  const CandSecondaryVertexTagInfo &svInfo) const
 {
     using namespace ROOT::Math;

     edm::RefToBase<Jet> jet = ipInfo.jet();
     math::XYZVector jetDir = jet->momentum().Unit();
     bool havePv = ipInfo.primaryVertex().isNonnull();
     GlobalPoint pv;
     if (havePv)
         pv = GlobalPoint(ipInfo.primaryVertex()->x(),
                          ipInfo.primaryVertex()->y(),
                          ipInfo.primaryVertex()->z());

     btag::Vertices::VertexType vtxType = btag::Vertices::NoVertex;

     TaggingVariableList vars;

     vars.insert(btau::jetPt, jet->pt(), true);
     vars.insert(btau::jetEta, jet->eta(), true);

     TrackKinematics allKinematics;
     TrackKinematics vertexKinematics;
     TrackKinematics trackKinematics;

     std::pair<double, double> vertexDist2D, vertexDist3D;
     std::pair<double, double> tracksDist2D, tracksDist3D;

     unsigned int nVertices = 0;
     unsigned int nVertexTracks = 0;
     unsigned int nTracks = 0;
     for(unsigned int i = 0; i < svInfo.nVertices(); i++) {
         const reco::VertexCompositePtrCandidate &vertex = svInfo.secondaryVertex(i);
         const std::vector<CandidatePtr> & tracks = vertex.daughterPtrVector();
         unsigned int n = 0;
         for(std::vector<CandidatePtr>::const_iterator track = tracks.begin(); track != tracks.end(); ++track)
                 n++;

         if (n < 1)
             continue;
         bool isTrackVertex = (n == 1);
         ++*(isTrackVertex ? &nTracks : &nVertices);

         addMeas(*(isTrackVertex ? &tracksDist2D : &vertexDist2D),
                     svInfo.flightDistance(i, true));
         addMeas(*(isTrackVertex ? &tracksDist3D : &vertexDist3D),
                     svInfo.flightDistance(i, false));

         TrackKinematics &kin = isTrackVertex ? trackKinematics : vertexKinematics;

         for(std::vector<CandidatePtr>::const_iterator track = tracks.begin(); track != tracks.end(); ++track) {
             kin.add(*track);
                 vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir, (*track)->momentum()), true);
             if (!isTrackVertex)
                 nVertexTracks++;
         }
     }

     Measurement1D dist2D, dist3D;
     if (nVertices) {
         vtxType = btag::Vertices::RecoVertex;

         if (nVertices == 1 && nTracks) {
             vertexDist2D.first += tracksDist2D.first;
             vertexDist2D.second += tracksDist2D.second;
             vertexDist3D.first += tracksDist3D.first;
             vertexDist3D.second += tracksDist3D.second;
             vertexKinematics += trackKinematics;
         }

         dist2D = Measurement1D(
                 vertexDist2D.first / vertexDist2D.second,
                 std::sqrt(1. / vertexDist2D.second));
         dist3D = Measurement1D(
                 vertexDist3D.first / vertexDist3D.second,
                 std::sqrt(1. / vertexDist3D.second));

         vars.insert(btau::jetNSecondaryVertices, nVertices, true);
         vars.insert(btau::vertexNTracks, nVertexTracks, true);
     } else if (nTracks) {
         vtxType = btag::Vertices::PseudoVertex;
         vertexKinematics = trackKinematics;

         dist2D = Measurement1D(
                 tracksDist2D.first / tracksDist2D.second,
                 std::sqrt(1. / tracksDist2D.second));
         dist3D = Measurement1D(
                 tracksDist3D.first / tracksDist3D.second,
                 std::sqrt(1. / tracksDist3D.second));
     }

     if (nVertices || nTracks) {
         vars.insert(btau::flightDistance2dVal, dist2D.value(), true);
         vars.insert(btau::flightDistance2dSig, dist2D.significance(), true);
         vars.insert(btau::flightDistance3dVal, dist3D.value(), true);
         vars.insert(btau::flightDistance3dSig, dist3D.significance(), true);
         vars.insert(btau::vertexJetDeltaR, Geom::deltaR(svInfo.flightDirection(0), jetDir),true);
         vars.insert(btau::jetNSingleTrackVertices, nTracks, true);
     }

     std::vector<std::size_t> indices = ipInfo.sortedIndexes(sortCriterium);
     const std::vector<btag::TrackIPData> &ipData = ipInfo.impactParameterData();
     const CandIPTagInfo::input_container &tracks = ipInfo.selectedTracks();

   const Track * trackPairV0Test[2];
     for(unsigned int i = 0; i < indices.size(); i++) {
         std::size_t idx = indices[i];
         const btag::TrackIPData &data = ipData[idx];
     const Track * trackPtr = reco::btag::toTrack(tracks[idx]);
     const Track &track = *trackPtr;

         // filter track

         if (!trackSelector(track, data, *jet, pv))
             continue;

         // add track to kinematics for all tracks in jet

         allKinematics.add(track);

         // check against all other tracks for V0 track pairs

         trackPairV0Test[0] = reco::btag::toTrack(tracks[idx]);
         bool ok = true;
         for(unsigned int j = 0; j < indices.size(); j++) {
             if (i == j)
                 continue;

             std::size_t pairIdx = indices[j];
             const btag::TrackIPData &pairTrackData = ipData[pairIdx];
       const Track * pairTrackPtr = reco::btag::toTrack(tracks[pairIdx]);
       const Track &pairTrack = *pairTrackPtr;

             if (!trackSelector(pairTrack, pairTrackData, *jet, pv))
                 continue;

       trackPairV0Test[1] = pairTrackPtr;
             if (!trackPairV0Filter(trackPairV0Test, 2)) {
                 ok = false;
                 break;
             }
         }
         if (!ok)
             continue;

         // add track variables

         math::XYZVector trackMom = track.momentum();
         double trackMag = std::sqrt(trackMom.Mag2());

         vars.insert(btau::trackSip3dVal, data.ip3d.value(), true);
         vars.insert(btau::trackSip3dSig, data.ip3d.significance(), true);
         vars.insert(btau::trackSip2dVal, data.ip2d.value(), true);
         vars.insert(btau::trackSip2dSig, data.ip2d.significance(), true);
         vars.insert(btau::trackJetDistVal, data.distanceToJetAxis.value(), true);
         vars.insert(btau::trackGhostTrackDistVal, data.distanceToGhostTrack.value(), true);
         vars.insert(btau::trackGhostTrackDistSig, data.distanceToGhostTrack.significance(), true);
         vars.insert(btau::trackGhostTrackWeight, data.ghostTrackWeight, true);
         vars.insert(btau::trackDecayLenVal, havePv ? (data.closestToGhostTrack - pv).mag() : -1.0, true);

         vars.insert(btau::trackMomentum, trackMag, true);
         vars.insert(btau::trackEta, trackMom.Eta(), true);

         vars.insert(btau::trackChi2, track.normalizedChi2(), true);
         vars.insert(btau::trackNPixelHits, track.hitPattern().pixelLayersWithMeasurement(), true);
         vars.insert(btau::trackNTotalHits, track.hitPattern().trackerLayersWithMeasurement(), true);
         vars.insert(btau::trackPtRel, VectorUtil::Perp(trackMom, jetDir), true);
         vars.insert(btau::trackDeltaR, VectorUtil::DeltaR(trackMom, jetDir), true);
     }

     vars.insert(btau::vertexCategory, vtxType, true);
     vars.insert(btau::trackSumJetDeltaR, VectorUtil::DeltaR(allKinematics.vectorSum(), jetDir), true);
     vars.insert(btau::trackSumJetEtRatio, allKinematics.vectorSum().Et() / ipInfo.jet()->et(), true);
     vars.insert(btau::trackSip3dSigAboveCharm, threshTrack(ipInfo, reco::btag::IP3DSig, *jet, pv).ip3d.significance(), true);
     vars.insert(btau::trackSip2dSigAboveCharm, threshTrack(ipInfo, reco::btag::IP2DSig, *jet, pv).ip2d.significance(), true);

     if (vtxType != btag::Vertices::NoVertex) {
         math::XYZTLorentzVector allSum = allKinematics.vectorSum();
         math::XYZTLorentzVector vertexSum = vertexKinematics.vectorSum();

         vars.insert(btau::vertexMass, vertexSum.M(), true);
         if (allKinematics.numberOfTracks())
             vars.insert(btau::vertexEnergyRatio, vertexSum.E() / allSum.E(), true);
         else
             vars.insert(btau::vertexEnergyRatio, 1, true);
     }

     vars.finalize();

     return vars;
 }
metsig::jet
Definition: SignAlgoResolutions.h:40

reco::TaggingVariableList
Definition: TaggingVariable.h:204

reco::btau::jetEta
Definition: TaggingVariable.h:37

dummy
Definition: DummySelector.h:36

reco::btag::IP2DSig
Definition: IPTagInfo.h:43

TrackSorting::getCriterium
reco::btag::SortCriteria getCriterium(const std::string &name)
Definition: TrackSorting.cc:11

nTracks
const unsigned int nTracks(const reco::Vertex &sv)
Definition: TemplatedVertexArbitrator.h:48

SecondaryVertexTagInfo.h

reco::btau::trackChi2
Definition: TaggingVariable.h:102

edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:253

mps_fire.i
i
Definition: mps_fire.py:269

reco::btau::trackEta
Definition: TaggingVariable.h:45

GhostTrackComputer::operator()
virtual reco::TaggingVariableList operator()(const reco::TrackIPTagInfo &ipInfo, const reco::SecondaryVertexTagInfo &svInfo) const
Definition: GhostTrackComputer.cc:136

reco::btau::trackSip2dSig
Definition: TaggingVariable.h:58

combinedSecondaryVertexCommon_cff.trackPairV0Filter
trackPairV0Filter
Definition: combinedSecondaryVertexCommon_cff.py:15

w
const double w
Definition: UKUtility.cc:23

TrackValidation_cff.nVertices
nVertices
Definition: TrackValidation_cff.py:310

ParticleMasses.h

reco::TrackBase::normalizedChi2
double normalizedChi2() const
chi-squared divided by n.d.o.f. (or chi-squared * 1e6 if n.d.o.f. is zero)
Definition: TrackBase.h:561

reco::btau::vertexJetDeltaR
Definition: TaggingVariable.h:83

reco::TrackKinematics::add
void add(const reco::Track &track, double weight=1.0)
Definition: TrackKinematics.cc:77

ParameterSet
Definition: Functions.h:16

reco::TemplatedSecondaryVertexTagInfo::secondaryVertex
const VTX & secondaryVertex(unsigned int index) const
Definition: TemplatedSecondaryVertexTagInfo.h:125

edm::Ref< TrackCollection >

AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255

GhostTrackComputer::GhostTrackComputer
GhostTrackComputer(const edm::ParameterSet &params)
Definition: GhostTrackComputer.cc:42

reco::Vertex::refittedTrack
Track refittedTrack(const TrackBaseRef &track) const

reco::btau::trackGhostTrackWeight
Definition: TaggingVariable.h:67

reco::Jet
Base class for all types of Jets.
Definition: Jet.h:20

convertSQLiteXML.ok
bool ok
Definition: convertSQLiteXML.py:97

reco::btau::etaRel
double etaRel(const math::XYZVector &dir, const math::XYZVector &track)
Definition: TaggingVariable.h:23

reco::btag::Vertices::RecoVertex
Definition: VertexTypes.h:18

reco::btau::trackMomentum
Definition: TaggingVariable.h:44

reco::Vertex::hasRefittedTracks
bool hasRefittedTracks() const
Checks whether refitted tracks are stored.
Definition: Vertex.h:149

reco::TaggingVariableList::finalize
void finalize(void)
Definition: TaggingVariable.cc:317

reco::VertexCompositePtrCandidate
Definition: VertexCompositePtrCandidate.h:16

reco::btau::trackSip3dSigAboveCharm
Definition: TaggingVariable.h:95

GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10

reco::btau::trackNTotalHits
Definition: TaggingVariable.h:103

Measurement1D::error
double error() const
Definition: Measurement1D.h:30

reco::TemplatedSecondaryVertexTagInfo< reco::TrackIPTagInfo, reco::Vertex >

reco::btau::trackSumJetEtRatio
Definition: TaggingVariable.h:69

muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27

reco::IPTagInfo::selectedTracks
const Container & selectedTracks() const
Definition: IPTagInfo.h:101

dropDeltaR
static edm::ParameterSet dropDeltaR(const edm::ParameterSet &pset)
Definition: GhostTrackComputer.cc:35

weight
Definition: weight.py:1

reco::btau::trackSip2dVal
Definition: TaggingVariable.h:57

std
Definition: JetResolutionObject.h:80

TrackFwd.h

GhostTrackComputer::minTrackWeight
double minTrackWeight
Definition: GhostTrackComputer.h:43

reco::HitPattern::pixelLayersWithMeasurement
int pixelLayersWithMeasurement() const
Definition: HitPattern.cc:499

reco::TrackBase::momentum
const Vector & momentum() const
track momentum vector
Definition: TrackBase.h:675

edm::RefVector::end
const_iterator end() const
Termination of iteration.
Definition: RefVector.h:253

reco::btag::toTrack
const reco::Track * toTrack(const reco::TrackBaseRef &t)
Definition: IPTagInfo.h:24

reco::btau::flightDistance3dVal
Definition: TaggingVariable.h:89

electrons_cff.ip3d
ip3d
Definition: electrons_cff.py:259

reco::HitPattern::trackerLayersWithMeasurement
int trackerLayersWithMeasurement() const
Definition: HitPattern.cc:518

reco::btau::trackSip2dSigAboveCharm
Definition: TaggingVariable.h:93

edm::RefToBase< Jet >

edm::RefVector::begin
const_iterator begin() const
Initialize an iterator over the RefVector.
Definition: RefVector.h:248

reco::CompositePtrCandidate::daughterPtrVector
virtual const daughters & daughterPtrVector() const
references to daughtes
Definition: CompositePtrCandidate.h:55

reco::btau::trackSip3dSig
Definition: TaggingVariable.h:60

reco::IPTagInfo::primaryVertex
const edm::Ref< VertexCollection > & primaryVertex() const
Definition: IPTagInfo.h:133

reco::btag::Vertices::PseudoVertex
Definition: VertexTypes.h:18

ParameterSet.h

ROOT::Math
Definition: Transform3DPJ.h:42

reco::TemplatedSecondaryVertexTagInfo::vertexTracks
input_container vertexTracks() const
Definition: TemplatedSecondaryVertexTagInfo.h:212

reco::btau::trackSumJetDeltaR
Definition: TaggingVariable.h:70

math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29

reco::btag::Vertices::NoVertex
Definition: VertexTypes.h:18

TrackSorting.h

reco::Vertex
Definition: Vertex.h:34

V0Filter.h

reco::btau::jetPt
Definition: TaggingVariable.h:35

addMeas
static void addMeas(std::pair< double, double > &sum, Measurement1D meas)
Definition: GhostTrackComputer.cc:127

VertexTypes.h

reco::TemplatedSecondaryVertexTagInfo::trackWeight
float trackWeight(unsigned int svIndex, unsigned int trackindex) const
Definition: TemplatedSecondaryVertexTagInfo.h:294

mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:18

edm::ParameterSet::addParameter
void addParameter(std::string const &name, T const &value)
Definition: ParameterSet.h:144

HiRegitMuonDetachedTripletStep_cff.DeltaR
DeltaR
Definition: HiRegitMuonDetachedTripletStep_cff.py:22

l1t::tracks
Definition: MicroGMTCancelOutUnit.h:12

VectorUtil.h

MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:6

reco::btag::Vertices::VertexType
VertexType
Definition: VertexTypes.h:18

reco::TrackKinematics
Definition: TrackKinematics.h:16

TrackIPTagInfo.h

edm::Ptr< Candidate >

GhostTrackComputer::charmCut
double charmCut
Definition: GhostTrackComputer.h:39

reco::btau::trackSip3dVal
Definition: TaggingVariable.h:59

LorentzVector.h

reco::IPTagInfo::sortedIndexes
std::vector< size_t > sortedIndexes(btag::SortCriteria mode=reco::btag::IP3DSig) const
Definition: IPTagInfo.h:238

GhostTrackComputer::trackPairV0Filter
reco::V0Filter trackPairV0Filter
Definition: GhostTrackComputer.h:45

reco::btau::flightDistance2dSig
Definition: TaggingVariable.h:88

reco::TemplatedSecondaryVertexTagInfo::flightDirection
const GlobalVector & flightDirection(unsigned int index) const
Definition: TemplatedSecondaryVertexTagInfo.h:156

GlobalVector.h

reco::IPTagInfo::impactParameterData
const std::vector< btag::TrackIPData > & impactParameterData() const
Definition: IPTagInfo.h:91

deltaR
double deltaR(double eta1, double eta2, double phi1, double phi2)
Definition: TreeUtility.cc:17

reco::btau::jetNSingleTrackVertices
Definition: TaggingVariable.h:76

reco::TemplatedSecondaryVertexTagInfo::nVertices
unsigned int nVertices() const
Definition: TemplatedSecondaryVertexTagInfo.h:131

reco::btau::vertexEnergyRatio
Definition: TaggingVariable.h:82

Exception.h

Measurement1D::significance
double significance() const
Definition: Measurement1D.h:32

reco::btau::trackGhostTrackDistSig
Definition: TaggingVariable.h:66

reco::btau::trackDeltaR
Definition: TaggingVariable.h:53

reco::TrackKinematics::numberOfTracks
unsigned int numberOfTracks() const
Definition: TrackKinematics.h:41

GhostTrackComputer::sortCriterium
reco::btag::SortCriteria sortCriterium
Definition: GhostTrackComputer.h:40

GhostTrackComputer::threshTrack
const reco::btag::TrackIPData & threshTrack(const reco::TrackIPTagInfo &trackIPTagInfo, const reco::btag::SortCriteria sort, const reco::Jet &jet, const GlobalPoint &pv) const

reco::TrackBase::hitPattern
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:446

HiIsolationCommonParameters_cff.track
track
Definition: HiIsolationCommonParameters_cff.py:9

TrackKinematics.h

math::XYZVector
XYZVectorD XYZVector
spatial vector with cartesian internal representation
Definition: Vector3D.h:30

reco::btau::flightDistance2dVal
Definition: TaggingVariable.h:87

Measurement1D.h

training_settings.idx
idx
Definition: training_settings.py:16

edm::RefVector< TrackCollection >

reco::Track
Definition: Track.h:28

Measurement1D::value
double value() const
Definition: Measurement1D.h:28

TrackSorting
Definition: TrackSorting.h:8

gen::n
int n
Definition: Cascade2Hadronizer.cc:79

TrackSelector.h

Measurement1D
Definition: Measurement1D.h:11

reco::btau::trackGhostTrackDistVal
Definition: TaggingVariable.h:65

Point3DBase< float, GlobalTag >

combinedSecondaryVertexCommon_cff.charmCut
charmCut
Definition: combinedSecondaryVertexCommon_cff.py:16

TaggingVariable.h

reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:43

edm
HLT enums.
Definition: AlignableModifier.h:17

data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:82

reco::btau::flightDistance3dSig
Definition: TaggingVariable.h:90

reco::TrackKinematics::vectorSum
const math::XYZTLorentzVector & vectorSum() const
Definition: TrackKinematics.h:44

Vector3D.h

reco::TemplatedSecondaryVertexTagInfo::flightDistance
Measurement1D flightDistance(unsigned int index, int dim=0) const
Definition: TemplatedSecondaryVertexTagInfo.h:151

vertexSelection_cff.sortCriterium
sortCriterium
Definition: vertexSelection_cff.py:5

reco::btag::SortCriteria
SortCriteria
Definition: IPTagInfo.h:43

edm::RefVectorIterator
Definition: EDProductfwd.h:26

GhostTrackComputer::trackNoDeltaRSelector
reco::TrackSelector trackNoDeltaRSelector
Definition: GhostTrackComputer.h:42

GhostTrackComputer.h

GhostTrackComputer::trackSelector
reco::TrackSelector trackSelector
Definition: GhostTrackComputer.h:41

edm::ParameterSet
Definition: ParameterSet.h:36

reco::IPTagInfo::input_container
Container input_container
Definition: IPTagInfo.h:53

Track.h

mps_merge.weight
weight
Definition: mps_merge.py:86

reco::btau::vertexNTracks
Definition: TaggingVariable.h:79

reco::btau::trackEtaRel
Definition: TaggingVariable.h:52

reco::IPTagInfo
Definition: IPTagInfo.h:51

reco::btau::jetNSecondaryVertices
Definition: TaggingVariable.h:75

reco::btau::trackPtRel
Definition: TaggingVariable.h:50

reco::btau::vertexCategory
Definition: TaggingVariable.h:72

reco::btau::trackJetDistVal
Definition: TaggingVariable.h:63

reco::btau::trackNPixelHits
Definition: TaggingVariable.h:104

reco::btau::trackDecayLenVal
Definition: TaggingVariable.h:61

reco::TaggingVariableList::insert
void insert(const TaggingVariable &variable, bool delayed=false)
Definition: TaggingVariable.cc:294

reco::btau::vertexMass
Definition: TaggingVariable.h:78

GlobalPoint.h

reco::btag::IP3DSig
Definition: IPTagInfo.h:43