CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
CombinedSVComputer.h
Go to the documentation of this file.
1 #ifndef RecoBTag_SecondaryVertex_CombinedSVComputer_h
2 #define RecoBTag_SecondaryVertex_CombinedSVComputer_h
3 
4 #include <iostream>
5 #include <cstddef>
6 #include <string>
7 #include <cmath>
8 #include <vector>
9 
10 #include <Math/VectorUtil.h>
11 
12 #include "FWCore/ParameterSet/interface/ParameterSet.h"
13 #include "FWCore/Utilities/interface/Exception.h"
14 #include "FWCore/ParameterSet/interface/ParameterSet.h"
15 
16 #include "DataFormats/Math/interface/Vector3D.h"
17 #include "DataFormats/Math/interface/LorentzVector.h"
18 #include "DataFormats/GeometryCommonDetAlgo/interface/Measurement1D.h"
19 #include "DataFormats/GeometryVector/interface/GlobalPoint.h"
20 #include "DataFormats/GeometryVector/interface/GlobalVector.h"
21 #include "DataFormats/GeometryVector/interface/VectorUtil.h"
22 #include "DataFormats/TrackReco/interface/Track.h"
23 #include "DataFormats/TrackReco/interface/TrackFwd.h"
24 #include "DataFormats/BTauReco/interface/SecondaryVertexTagInfo.h"
25 #include "DataFormats/BTauReco/interface/CandSecondaryVertexTagInfo.h"
26 #include "DataFormats/BTauReco/interface/TaggingVariable.h"
27 #include "DataFormats/BTauReco/interface/VertexTypes.h"
28 #include "DataFormats/BTauReco/interface/ParticleMasses.h"
29 #include "DataFormats/JetReco/interface/PFJet.h"
30 #include "DataFormats/PatCandidates/interface/Jet.h"
31 
32 #include "RecoBTag/SecondaryVertex/interface/TrackSelector.h"
33 #include "RecoBTag/SecondaryVertex/interface/V0Filter.h"
34 #include "RecoBTag/SecondaryVertex/interface/TrackSorting.h"
35 #include "RecoBTag/SecondaryVertex/interface/TrackKinematics.h"
36 
37 
38 #define range_for(i, x) \
39  for(int i = (x).begin; i != (x).end; i += (x).increment)
40 
41 
42 class CombinedSVComputer {
43  public:
44  explicit CombinedSVComputer(const edm::ParameterSet &params);
45 
46  virtual reco::TaggingVariableList
47  operator () (const reco::TrackIPTagInfo &ipInfo,
48  const reco::SecondaryVertexTagInfo &svInfo) const;
49  virtual reco::TaggingVariableList
50  operator () (const reco::CandIPTagInfo &ipInfo,
51  const reco::CandSecondaryVertexTagInfo &svInfo) const;
52 
53  struct IterationRange {
54  int begin, end, increment;
55  };
56  double flipValue(double value, bool vertex) const;
57  IterationRange flipIterate(int size, bool vertex) const;
58 
59  edm::ParameterSet dropDeltaR(const edm::ParameterSet &pset) const;
60 
61  const reco::btag::TrackIPData &
62  threshTrack(const reco::CandIPTagInfo &trackIPTagInfo,
63  const reco::btag::SortCriteria sort,
64  const reco::Jet &jet,
65  const GlobalPoint &pv) const;
66  const reco::btag::TrackIPData &
67  threshTrack(const reco::TrackIPTagInfo &trackIPTagInfo,
68  const reco::btag::SortCriteria sort,
69  const reco::Jet &jet,
70  const GlobalPoint &pv) const;
71  template <class SVTI,class IPTI>
72  void fillCommonVariables(reco::TaggingVariableList & vars, reco::TrackKinematics & vertexKinematics,
73  const IPTI & ipInfo,const SVTI & svInfo,
74  double & vtx_track_ptSum, double & vtx_track_ESum) const;
75 
76  private:
77  bool trackFlip;
78  bool vertexFlip;
79  double charmCut;
80  reco::btag::SortCriteria sortCriterium;
81  reco::TrackSelector trackSelector;
82  reco::TrackSelector trackNoDeltaRSelector;
83  reco::TrackSelector trackPseudoSelector;
84  unsigned int pseudoMultiplicityMin;
85  unsigned int trackMultiplicityMin;
86  double minTrackWeight;
87  bool useTrackWeights;
88  bool vertexMassCorrection;
89  reco::V0Filter pseudoVertexV0Filter;
90  reco::V0Filter trackPairV0Filter;
91  std::vector<reco::btau::TaggingVariableName> taggingVariables;
92 };
93 
94 template <class SVTI,class IPTI>
95 void CombinedSVComputer::fillCommonVariables(reco::TaggingVariableList & vars, reco::TrackKinematics & vertexKinematics,
96  const IPTI & ipInfo, const SVTI & svInfo,
97  double & vtx_track_ptSum, double & vtx_track_ESum) const
98 {
99  using namespace ROOT::Math;
100  using namespace reco;
101 
102  typedef typename IPTI::input_container Container;
103  typedef typename Container::value_type TrackRef;
104 
105  edm::RefToBase<Jet> jet = ipInfo.jet();
106  math::XYZVector jetDir = jet->momentum().Unit();
107  bool havePv = ipInfo.primaryVertex().isNonnull();
108  GlobalPoint pv;
109  if (havePv)
110  pv = GlobalPoint(ipInfo.primaryVertex()->x(),
111  ipInfo.primaryVertex()->y(),
112  ipInfo.primaryVertex()->z());
113 
114  btag::Vertices::VertexType vtxType = btag::Vertices::NoVertex;
115 
116 
117  vars.insert(btau::jetPt, jet->pt(), true);
118  vars.insert(btau::jetEta, jet->eta(), true);
119 
120  if (ipInfo.selectedTracks().size() < trackMultiplicityMin)
121  return;
122 
123  vars.insert(btau::jetNTracks, ipInfo.selectedTracks().size(), true);
124 
125  TrackKinematics allKinematics;
126  TrackKinematics trackJetKinematics;
127 
128  double jet_track_ESum= 0.;
129 
130  int vtx = -1;
131 
132  IterationRange range = flipIterate(svInfo.nVertices(), true);
133  range_for(i , range) {
134  if (vtx < 0) vtx = i;
135  }
136 
137  if (vtx >= 0) {
138  vtxType = btag::Vertices::RecoVertex;
139 
140  vars.insert(btau::flightDistance2dVal,flipValue(svInfo.flightDistance(vtx, true).value(),true),true);
141  vars.insert(btau::flightDistance2dSig,flipValue(svInfo.flightDistance(vtx, true).significance(),true),true);
142  vars.insert(btau::flightDistance3dVal,flipValue(svInfo.flightDistance(vtx, false).value(),true),true);
143  vars.insert(btau::flightDistance3dSig,flipValue(svInfo.flightDistance(vtx, false).significance(),true),true);
144  vars.insert(btau::vertexJetDeltaR,Geom::deltaR(svInfo.flightDirection(vtx), jetDir),true);
145  vars.insert(btau::jetNSecondaryVertices, svInfo.nVertices(), true);
146  }
147 
148  std::vector<std::size_t> indices = ipInfo.sortedIndexes(sortCriterium);
149  const std::vector<reco::btag::TrackIPData> &ipData = ipInfo.impactParameterData();
150 
151  const Container &tracks = ipInfo.selectedTracks();
152  std::vector<TrackRef> pseudoVertexTracks;
153 
154  std::vector<TrackRef> trackPairV0Test(2);
155  range = flipIterate(indices.size(), false);
156  range_for(i, range) {
157  std::size_t idx = indices[i];
158  const reco::btag::TrackIPData &data = ipData[idx];
159  const TrackRef &track = tracks[idx];
160 
161  jet_track_ESum += std::sqrt(track->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
162 
163  // add track to kinematics for all tracks in jet
164  //allKinematics.add(track); // would make more sense for some variables, e.g. vertexEnergyRatio nicely between 0 and 1, but not necessarily the best option for the discriminating power...
165 
166  // filter track -> this track selection can be tighter than the vertex track selection (used to fill the track related variables...)
167  if (!trackSelector(track, data, *jet, pv))
168  continue;
169 
170  // add track to kinematics for all tracks in jet
171  allKinematics.add(track);
172 
173  // if no vertex was reconstructed, attempt pseudo vertex
174  if (vtxType == btag::Vertices::NoVertex && trackPseudoSelector(track, data, *jet, pv)) {
175  pseudoVertexTracks.push_back(track);
176  vertexKinematics.add(track);
177  }
178 
179  // check against all other tracks for V0 track pairs
180  trackPairV0Test[0] = track;
181  bool ok = true;
182  range_for(j, range) {
183  if (i == j)
184  continue;
185 
186  std::size_t pairIdx = indices[j];
187  const reco::btag::TrackIPData &pairTrackData = ipData[pairIdx];
188  const TrackRef &pairTrack = tracks[pairIdx];
189 
190  if (!trackSelector(pairTrack, pairTrackData, *jet, pv))
191  continue;
192 
193  trackPairV0Test[1] = pairTrack;
194  if (!trackPairV0Filter(trackPairV0Test)) {
195  ok = false;
196  break;
197  }
198  }
199  if (!ok)
200  continue;
201 
202  trackJetKinematics.add(track);
203 
204  // add track variables
205  math::XYZVector trackMom = track->momentum();
206  double trackMag = std::sqrt(trackMom.Mag2());
207 
208  vars.insert(btau::trackSip3dVal, flipValue(data.ip3d.value(), false), true);
209  vars.insert(btau::trackSip3dSig, flipValue(data.ip3d.significance(), false), true);
210  vars.insert(btau::trackSip2dVal, flipValue(data.ip2d.value(), false), true);
211  vars.insert(btau::trackSip2dSig, flipValue(data.ip2d.significance(), false), true);
212  vars.insert(btau::trackJetDistVal, data.distanceToJetAxis.value(), true);
213 // vars.insert(btau::trackJetDistSig, data.distanceToJetAxis.significance(), true);
214 // vars.insert(btau::trackFirstTrackDist, data.distanceToFirstTrack, true);
215 // vars.insert(btau::trackGhostTrackVal, data.distanceToGhostTrack.value(), true);
216 // vars.insert(btau::trackGhostTrackSig, data.distanceToGhostTrack.significance(), true);
217  vars.insert(btau::trackDecayLenVal, havePv ? (data.closestToJetAxis - pv).mag() : -1.0, true);
218 
219  vars.insert(btau::trackMomentum, trackMag, true);
220  vars.insert(btau::trackEta, trackMom.Eta(), true);
221 
222  vars.insert(btau::trackPtRel, VectorUtil::Perp(trackMom, jetDir), true);
223  vars.insert(btau::trackPPar, jetDir.Dot(trackMom), true);
224  vars.insert(btau::trackDeltaR, VectorUtil::DeltaR(trackMom, jetDir), true);
225  vars.insert(btau::trackPtRatio, VectorUtil::Perp(trackMom, jetDir) / trackMag, true);
226  vars.insert(btau::trackPParRatio, jetDir.Dot(trackMom) / trackMag, true);
227  }
228 
229  if (vtxType == btag::Vertices::NoVertex && vertexKinematics.numberOfTracks() >= pseudoMultiplicityMin && pseudoVertexV0Filter(pseudoVertexTracks))
230  {
231  vtxType = btag::Vertices::PseudoVertex;
232  for(typename std::vector<TrackRef>::const_iterator trkIt = pseudoVertexTracks.begin(); trkIt != pseudoVertexTracks.end(); ++trkIt)
233  {
234  vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir,(*trkIt)->momentum()), true);
235  vtx_track_ptSum += std::sqrt((*trkIt)->momentum().Perp2());
236  vtx_track_ESum += std::sqrt((*trkIt)->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
237  }
238  }
239 
240  vars.insert(btau::vertexCategory, vtxType, true);
241 
242  vars.insert(btau::trackJetPt, trackJetKinematics.vectorSum().Pt(), true);
243  vars.insert(btau::trackSumJetDeltaR,VectorUtil::DeltaR(allKinematics.vectorSum(), jetDir), true);
244  vars.insert(btau::trackSumJetEtRatio,allKinematics.vectorSum().Et() / ipInfo.jet()->et(), true);
245 
246  vars.insert(btau::trackSip3dSigAboveCharm, flipValue(threshTrack(ipInfo, reco::btag::IP3DSig, *jet, pv).ip3d.significance(),false),true);
247  vars.insert(btau::trackSip3dValAboveCharm, flipValue(threshTrack(ipInfo, reco::btag::IP3DSig, *jet, pv).ip3d.value(),false),true);
248  vars.insert(btau::trackSip2dSigAboveCharm, flipValue(threshTrack(ipInfo, reco::btag::IP2DSig, *jet, pv).ip2d.significance(),false),true);
249  vars.insert(btau::trackSip2dValAboveCharm, flipValue(threshTrack(ipInfo, reco::btag::IP2DSig, *jet, pv).ip2d.value(),false),true);
250 
251  if (vtxType != btag::Vertices::NoVertex) {
252  math::XYZTLorentzVector allSum = useTrackWeights
253  ? allKinematics.weightedVectorSum()
254  : allKinematics.vectorSum();
255  math::XYZTLorentzVector vertexSum = useTrackWeights
256  ? vertexKinematics.weightedVectorSum()
257  : vertexKinematics.vectorSum();
258 
259  if (vtxType != btag::Vertices::RecoVertex) {
260  vars.insert(btau::vertexNTracks,vertexKinematics.numberOfTracks(), true);
261  vars.insert(btau::vertexJetDeltaR,VectorUtil::DeltaR(vertexSum, jetDir), true);
262  }
263 
264  double vertexMass = vertexSum.M();
265  if (vtxType == btag::Vertices::RecoVertex &&
266  vertexMassCorrection) {
267  GlobalVector dir = svInfo.flightDirection(vtx);
268  double vertexPt2 = math::XYZVector(dir.x(), dir.y(), dir.z()).Cross(vertexSum).Mag2() / dir.mag2();
269  vertexMass = std::sqrt(vertexMass * vertexMass + vertexPt2) + std::sqrt(vertexPt2);
270  }
271  vars.insert(btau::vertexMass, vertexMass, true);
272 
273  double varPi = (vertexMass/5.2794) * (vtx_track_ESum /jet_track_ESum); // 5.2794 should be the average B meson mass of PDG! CHECK!!!
274  vars.insert(btau::massVertexEnergyFraction, varPi / (varPi + 0.04), true);
275  double varB = (std::sqrt(5.2794) * vtx_track_ptSum) / ( vertexMass * std::sqrt(jet->pt()));
276  vars.insert(btau::vertexBoostOverSqrtJetPt,varB*varB/(varB*varB + 10.), true);
277 
278  if (allKinematics.numberOfTracks()) {
279  vars.insert(btau::vertexEnergyRatio, vertexSum.E() / allSum.E(), true);
280  }
281  else {
282  vars.insert(btau::vertexEnergyRatio, 1, true);
283  }
284  }
285 
286  reco::PFJet const * pfJet = dynamic_cast<reco::PFJet const *>( &* jet ) ;
287  pat::Jet const * patJet = dynamic_cast<pat::Jet const *>( &* jet ) ;
288  if ( pfJet != 0 )
289  {
290  vars.insert(btau::chargedHadronEnergyFraction,pfJet->chargedHadronEnergyFraction(), true);
291  vars.insert(btau::neutralHadronEnergyFraction,pfJet->neutralHadronEnergyFraction(), true);
292  vars.insert(btau::photonEnergyFraction,pfJet->photonEnergyFraction(), true);
293  vars.insert(btau::electronEnergyFraction,pfJet->electronEnergyFraction(), true);
294  vars.insert(btau::muonEnergyFraction,pfJet->muonEnergyFraction(), true);
295  vars.insert(btau::chargedHadronMultiplicity,pfJet->chargedHadronMultiplicity(), true);
296  vars.insert(btau::neutralHadronMultiplicity,pfJet->neutralHadronMultiplicity(), true);
297  vars.insert(btau::photonMultiplicity,pfJet->photonMultiplicity(), true);
298  vars.insert(btau::electronMultiplicity,pfJet->electronMultiplicity(), true);
299  vars.insert(btau::muonMultiplicity,pfJet->muonMultiplicity(), true);
300  vars.insert(btau::hadronMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity(), true);
301  vars.insert(btau::hadronPhotonMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity()+pfJet->photonMultiplicity(), true);
302  vars.insert(btau::totalMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity()+pfJet->photonMultiplicity()+pfJet->electronMultiplicity()+pfJet->muonMultiplicity(), true);
303 
304  }
305  else if( patJet != 0 && patJet->isPFJet() )
306  {
307  vars.insert(btau::chargedHadronEnergyFraction,patJet->chargedHadronEnergyFraction(), true);
308  vars.insert(btau::neutralHadronEnergyFraction,patJet->neutralHadronEnergyFraction(), true);
309  vars.insert(btau::photonEnergyFraction,patJet->photonEnergyFraction(), true);
310  vars.insert(btau::electronEnergyFraction,patJet->electronEnergyFraction(), true);
311  vars.insert(btau::muonEnergyFraction,patJet->muonEnergyFraction(), true);
312  vars.insert(btau::chargedHadronMultiplicity,patJet->chargedHadronMultiplicity(), true);
313  vars.insert(btau::neutralHadronMultiplicity,patJet->neutralHadronMultiplicity(), true);
314  vars.insert(btau::photonMultiplicity,patJet->photonMultiplicity(), true);
315  vars.insert(btau::electronMultiplicity,patJet->electronMultiplicity(), true);
316  vars.insert(btau::muonMultiplicity,patJet->muonMultiplicity(), true);
317  vars.insert(btau::hadronMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity(), true);
318  vars.insert(btau::hadronPhotonMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity()+patJet->photonMultiplicity(), true);
319  vars.insert(btau::totalMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity()+patJet->photonMultiplicity()+patJet->electronMultiplicity()+patJet->muonMultiplicity(), true);
320 
321  }
322  else
323  {
324  vars.insert(btau::chargedHadronEnergyFraction,0., true);
325  vars.insert(btau::neutralHadronEnergyFraction,0., true);
326  vars.insert(btau::photonEnergyFraction,0., true);
327  vars.insert(btau::electronEnergyFraction,0., true);
328  vars.insert(btau::muonEnergyFraction,0., true);
329  vars.insert(btau::chargedHadronMultiplicity,0, true);
330  vars.insert(btau::neutralHadronMultiplicity,0, true);
331  vars.insert(btau::photonMultiplicity,0, true);
332  vars.insert(btau::electronMultiplicity,0, true);
333  vars.insert(btau::muonMultiplicity,0, true);
334  vars.insert(btau::hadronMultiplicity,0, true);
335  vars.insert(btau::hadronPhotonMultiplicity,0, true);
336  vars.insert(btau::totalMultiplicity,0, true);
337  }
338 }
339 
340 
341 #endif // RecoBTag_SecondaryVertex_CombinedSVComputer_h
CombinedSVComputer::trackSelector
reco::TrackSelector trackSelector
Definition: CombinedSVComputer.h:81
reco::ParticleMasses::piPlus
const double piPlus
Definition: ParticleMasses.h:9
i
int i
Definition: DBlmapReader.cc:9
PV3DBase::mag2
T mag2() const
Definition: PV3DBase.h:66
reco::TrackKinematics::weightedVectorSum
const math::XYZTLorentzVector & weightedVectorSum() const
Definition: TrackKinematics.h:46
CombinedSVComputer::pseudoMultiplicityMin
unsigned int pseudoMultiplicityMin
Definition: CombinedSVComputer.h:84
reco::TrackKinematics::add
void add(const reco::Track &track, double weight=1.0)
Definition: TrackKinematics.cc:77
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:23
reco::btag::TrackIPData::ip2d
Measurement1D ip2d
Definition: IPTagInfo.h:31
CombinedSVComputer::trackNoDeltaRSelector
reco::TrackSelector trackNoDeltaRSelector
Definition: CombinedSVComputer.h:82
CombinedSVComputer::pseudoVertexV0Filter
reco::V0Filter pseudoVertexV0Filter
Definition: CombinedSVComputer.h:89
TrackValidation_cff.pset
tuple pset
Definition: TrackValidation_cff.py:374
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
PV3DBase::y
T y() const
Definition: PV3DBase.h:63
CombinedSVComputer::operator()
virtual reco::TaggingVariableList operator()(const reco::TrackIPTagInfo &ipInfo, const reco::SecondaryVertexTagInfo &svInfo) const
Definition: CombinedSVComputer.cc:134
CombinedSVComputer::CombinedSVComputer
CombinedSVComputer(const edm::ParameterSet &params)
Definition: CombinedSVComputer.cc:13
dt_dqm_sourceclient_common_cff.reco
tuple reco
Definition: dt_dqm_sourceclient_common_cff.py:107
reco::PFJet
Jets made from PFObjects.
Definition: PFJet.h:21
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
CombinedSVComputer::sortCriterium
reco::btag::SortCriteria sortCriterium
Definition: CombinedSVComputer.h:80
CombinedSVComputer::trackPseudoSelector
reco::TrackSelector trackPseudoSelector
Definition: CombinedSVComputer.h:83
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:18
PV3DBase::z
T z() const
Definition: PV3DBase.h:64
j
int j
Definition: DBlmapReader.cc:9
reco::btag::TrackIPData::ip3d
Measurement1D ip3d
Definition: IPTagInfo.h:32
CombinedSVComputer::flipIterate
IterationRange flipIterate(int size, bool vertex) const
Definition: CombinedSVComputer.cc:37
CombinedSVComputer::trackPairV0Filter
reco::V0Filter trackPairV0Filter
Definition: CombinedSVComputer.h:90
deltaR
double deltaR(double eta1, double eta2, double phi1, double phi2)
Definition: TreeUtility.cc:17
CombinedSVComputer::taggingVariables
std::vector< reco::btau::TaggingVariableName > taggingVariables
Definition: CombinedSVComputer.h:91
Measurement1D::significance
double significance() const
Definition: Measurement1D.h:32
reco::TrackKinematics::numberOfTracks
unsigned int numberOfTracks() const
Definition: TrackKinematics.h:41
range_for
#define range_for(i, x)
Definition: CombinedSVComputer.h:38
reco::btag::TrackIPData::closestToJetAxis
GlobalPoint closestToJetAxis
Definition: IPTagInfo.h:29
testEve_cfg.tracks
tuple tracks
Definition: testEve_cfg.py:39
math::XYZVector
XYZVectorD XYZVector
spatial vector with cartesian internal representation
Definition: Vector3D.h:30
customizeTrackingMonitorSeedNumber.idx
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
Definition: customizeTrackingMonitorSeedNumber.py:15
CombinedSVComputer::flipValue
double flipValue(double value, bool vertex) const
Definition: CombinedSVComputer.cc:32
reco::TrackRef
edm::Ref< TrackCollection > TrackRef
persistent reference to a Track
Definition: TrackFwd.h:20
pat::Jet
Analysis-level calorimeter jet class.
Definition: Jet.h:77
CombinedSVComputer::dropDeltaR
edm::ParameterSet dropDeltaR(const edm::ParameterSet &pset) const
Definition: CombinedSVComputer.cc:6
Measurement1D::value
double value() const
Definition: Measurement1D.h:28
CombinedSVComputer::threshTrack
const reco::btag::TrackIPData & threshTrack(const reco::CandIPTagInfo &trackIPTagInfo, const reco::btag::SortCriteria sort, const reco::Jet &jet, const GlobalPoint &pv) const
reco::btag::TrackIPData::distanceToJetAxis
Measurement1D distanceToJetAxis
Definition: IPTagInfo.h:33
CombinedSVComputer::fillCommonVariables
void fillCommonVariables(reco::TaggingVariableList &vars, reco::TrackKinematics &vertexKinematics, const IPTI &ipInfo, const SVTI &svInfo, double &vtx_track_ptSum, double &vtx_track_ESum) const
Definition: CombinedSVComputer.h:95
data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:82
reco::TrackKinematics::vectorSum
const math::XYZTLorentzVector & vectorSum() const
Definition: TrackKinematics.h:44
dir
dbl *** dir
Definition: mlp_gen.cc:35
HLT_FULL_cff.DeltaR
tuple DeltaR
Definition: HLT_FULL_cff.py:803
PV3DBase::x
T x() const
Definition: PV3DBase.h:62
reco::JetExtendedAssociation::Container
edm::AssociationVector< reco::JetRefBaseProd, Values > Container
Definition: JetExtendedAssociation.h:29
findQualityFiles.size
tuple size
Write out results.
Definition: findQualityFiles.py:442
reco::TaggingVariableList::insert
void insert(const TaggingVariable &variable, bool delayed=false)
Definition: TaggingVariable.cc:226
CombinedSVComputer::trackMultiplicityMin
unsigned int trackMultiplicityMin
Definition: CombinedSVComputer.h:85
Generated for CMSSW Reference Manual by doxygen 1.8.5