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


     const 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) {

     const math::XYZTLorentzVector &allSum = allKinematics.vectorSum();

     const 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


     const 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) {

     const math::XYZTLorentzVector &allSum = allKinematics.vectorSum();

     const 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:47

reco::TaggingVariableList
Definition: TaggingVariable.h:194

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

MetAnalyzer.pv
def pv
Definition: MetAnalyzer.py:7

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

HLT_FULL_cff.deltaR
tuple deltaR
Definition: HLT_FULL_cff.py:6144

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

SecondaryVertexTagInfo.h

dqmiolumiharvest.j
tuple j
Definition: dqmiolumiharvest.py:66

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

reco::LeafCandidate::momentum
Vector momentum() const final
spatial momentum vector
Definition: LeafCandidate.h:118

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

mps_fire.i
i
Definition: mps_fire.py:428

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

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

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

reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:146

HLT_FULL_cff.trackPairV0Filter
tuple trackPairV0Filter
Definition: HLT_FULL_cff.py:6050

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:593

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

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

ParameterSet
Definition: Functions.h:16

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

edm::Ref< TrackCollection >

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

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

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

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

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

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

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

reco::VertexCompositePtrCandidate
Definition: VertexCompositePtrCandidate.h:16

TrackValidation_cff.pset
tuple pset
Definition: TrackValidation_cff.py:591

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

GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10

HLT_FULL_cff.nVertices
tuple nVertices
Definition: HLT_FULL_cff.py:38606

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

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

reco::TemplatedSecondaryVertexTagInfo
Definition: TemplatedSecondaryVertexTagInfo.h:47

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

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

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

submitPVValidationJobs.params
list params
Definition: submitPVValidationJobs.py:487

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

tracks
auto const & tracks
cannot be loose
Definition: CAHitNtupletGeneratorKernelsImpl.h:148

TrackFwd.h

GhostTrackComputer::minTrackWeight
double minTrackWeight
Definition: GhostTrackComputer.h:39

HLT_FULL_cff.track
tuple track
Definition: HLT_FULL_cff.py:10468

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

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

dt_dqm_sourceclient_common_cff.reco
tuple reco
Definition: dt_dqm_sourceclient_common_cff.py:111

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

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

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

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

BeamSpotPI::nTracks
Definition: BeamSpotPayloadInspectorHelper.h:45

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

edm::RefToBase< Jet >

AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256

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

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

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

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

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

ParameterSet.h

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

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

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:35

V0Filter.h

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

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

VertexTypes.h

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

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

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

VectorUtil.h

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:35

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

LorentzVector.h

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

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

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

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

GlobalVector.h

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

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

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

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

Exception.h

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

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

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

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:504

TrackKinematics.h

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

HLT_FULL_cff.charmCut
tuple charmCut
Definition: HLT_FULL_cff.py:6051

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

Measurement1D.h

edm::RefVector< TrackCollection >

reco::Track
Definition: Track.h:27

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

TrackSelector.h

Measurement1D
Definition: Measurement1D.h:11

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

Point3DBase< float, GlobalTag >

TaggingVariable.h

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

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

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

reco::Vertex::refittedTrack
Track refittedTrack(const TrackBaseRef &track) const
Definition: Vertex.cc:91

Vector3D.h

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

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

edm::RefVectorIterator
Definition: EDProductfwd.h:33

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

GhostTrackComputer.h

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

Track.h

edm::ParameterSet
Definition: ParameterSet.h:47

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

w
T w() const
Definition: extBasic3DVector.h:225

vars
vars
Definition: DeepTauId.cc:164

histoStyle.weight
int weight
Definition: histoStyle.py:51

HLT_FULL_cff.DeltaR
tuple DeltaR
Definition: HLT_FULL_cff.py:321

dqmdumpme.indices
list indices
Definition: dqmdumpme.py:50

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

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

convertSQLiteXML.ok
ok
Definition: convertSQLiteXML.py:98

reco::IPTagInfo
Definition: IPTagInfo.h:48

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

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

dqmiodumpmetadata.n
int n
Definition: dqmiodumpmetadata.py:28

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

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

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

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

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

GlobalPoint.h

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

valSkim_cff.trackSelector
tuple trackSelector
Tracks selection.
Definition: valSkim_cff.py:4

reco::LeafCandidate::eta
double eta() const final
momentum pseudorapidity
Definition: LeafCandidate.h:152