CMS 3D CMS Logo
List of all members | Classes | Public Member Functions | Private Attributes
CombinedSVComputer Class Reference

#include <CombinedSVComputer.h>

Inheritance diagram for CombinedSVComputer:
CombinedSVSoftLeptonComputer

Classes

struct  IterationRange
 

Public Member Functions

 CombinedSVComputer (const edm::ParameterSet &params)
 
edm::ParameterSet dropDeltaR (const edm::ParameterSet &pset) const
 
template<class SVTI , class IPTI >
void fillCommonVariables (reco::TaggingVariableList &vars, reco::TrackKinematics &vertexKinematics, const IPTI &ipInfo, const SVTI &svInfo, double &vtx_track_ptSum, double &vtx_track_ESum) const
 
IterationRange flipIterate (int size, bool vertex) const
 
double flipValue (double value, bool vertex) const
 
virtual reco::TaggingVariableList operator() (const reco::TrackIPTagInfo &ipInfo, const reco::SecondaryVertexTagInfo &svInfo) const
 
virtual reco::TaggingVariableList operator() (const reco::CandIPTagInfo &ipInfo, const reco::CandSecondaryVertexTagInfo &svInfo) const
 
const reco::btag::TrackIPData & threshTrack (const reco::CandIPTagInfo &trackIPTagInfo, const reco::btag::SortCriteria sort, const reco::Jet &jet, const GlobalPoint &pv) const
 
const reco::btag::TrackIPData & threshTrack (const reco::TrackIPTagInfo &trackIPTagInfo, const reco::btag::SortCriteria sort, const reco::Jet &jet, const GlobalPoint &pv) const
 
virtual ~CombinedSVComputer ()=default
 

Private Attributes

double charmCut
 
double minTrackWeight
 
unsigned int pseudoMultiplicityMin
 
reco::V0Filter pseudoVertexV0Filter
 
reco::btag::SortCriteria sortCriterium
 
std::vector< reco::btau::TaggingVariableName > taggingVariables
 
bool trackFlip
 
unsigned int trackMultiplicityMin
 
reco::TrackSelector trackNoDeltaRSelector
 
reco::V0Filter trackPairV0Filter
 
reco::TrackSelector trackPseudoSelector
 
reco::TrackSelector trackSelector
 
bool useTrackWeights
 
bool vertexFlip
 
bool vertexMassCorrection
 

Detailed Description

Definition at line 42 of file CombinedSVComputer.h.

Constructor & Destructor Documentation

CombinedSVComputer::CombinedSVComputer ( const edm::ParameterSet &  params)
explicit

Definition at line 13 of file CombinedSVComputer.cc.

13  :
14  trackFlip(params.getParameter<bool>("trackFlip")),
15  vertexFlip(params.getParameter<bool>("vertexFlip")),
16  charmCut(params.getParameter<double>("charmCut")),
17  sortCriterium(TrackSorting::getCriterium(params.getParameter<std::string>("trackSort"))),
18  trackSelector(params.getParameter<edm::ParameterSet>("trackSelection")),
19  trackNoDeltaRSelector(dropDeltaR(params.getParameter<edm::ParameterSet>("trackSelection"))),
20  trackPseudoSelector(params.getParameter<edm::ParameterSet>("trackPseudoSelection")),
21  pseudoMultiplicityMin(params.getParameter<unsigned int>("pseudoMultiplicityMin")),
22  trackMultiplicityMin(params.getParameter<unsigned int>("trackMultiplicityMin")),
23  minTrackWeight(params.getParameter<double>("minimumTrackWeight")),
24  useTrackWeights(params.getParameter<bool>("useTrackWeights")),
25  vertexMassCorrection(params.getParameter<bool>("correctVertexMass")),
26  pseudoVertexV0Filter(params.getParameter<edm::ParameterSet>("pseudoVertexV0Filter")),
27  trackPairV0Filter(params.getParameter<edm::ParameterSet>("trackPairV0Filter"))
28 {
29 
30 }
CombinedSVComputer::trackSelector
reco::TrackSelector trackSelector
Definition: CombinedSVComputer.h:81
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TrackSorting::getCriterium
reco::btag::SortCriteria getCriterium(const std::string &name)
Definition: TrackSorting.cc:11
CombinedSVComputer::pseudoMultiplicityMin
unsigned int pseudoMultiplicityMin
Definition: CombinedSVComputer.h:84
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
CombinedSVComputer::trackNoDeltaRSelector
reco::TrackSelector trackNoDeltaRSelector
Definition: CombinedSVComputer.h:82
CombinedSVComputer::pseudoVertexV0Filter
reco::V0Filter pseudoVertexV0Filter
Definition: CombinedSVComputer.h:89
CombinedSVComputer::sortCriterium
reco::btag::SortCriteria sortCriterium
Definition: CombinedSVComputer.h:80
CombinedSVComputer::trackPseudoSelector
reco::TrackSelector trackPseudoSelector
Definition: CombinedSVComputer.h:83
CombinedSVComputer::trackPairV0Filter
reco::V0Filter trackPairV0Filter
Definition: CombinedSVComputer.h:90
CombinedSVComputer::dropDeltaR
edm::ParameterSet dropDeltaR(const edm::ParameterSet &pset) const
Definition: CombinedSVComputer.cc:6
CombinedSVComputer::trackMultiplicityMin
unsigned int trackMultiplicityMin
Definition: CombinedSVComputer.h:85
virtual CombinedSVComputer::~CombinedSVComputer ( )
virtualdefault

Member Function Documentation

edm::ParameterSet CombinedSVComputer::dropDeltaR ( const edm::ParameterSet &  pset) const
inline

Definition at line 6 of file CombinedSVComputer.cc.

References edm::ParameterSet::addParameter().

7 {
8  edm::ParameterSet psetCopy(pset);
9  psetCopy.addParameter<double>("jetDeltaRMax", 99999.0);
10  return psetCopy;
11 }
template<class SVTI , class IPTI >
void CombinedSVComputer::fillCommonVariables ( reco::TaggingVariableList &  vars,
reco::TrackKinematics &  vertexKinematics,
const IPTI &  ipInfo,
const SVTI &  svInfo,
double &  vtx_track_ptSum,
double &  vtx_track_ESum 
) const

Definition at line 95 of file CombinedSVComputer.h.

References reco::TrackKinematics::add(), reco::PFJet::chargedHadronEnergyFraction(), reco::btau::chargedHadronEnergyFraction, pat::Jet::chargedHadronEnergyFraction(), reco::btau::chargedHadronMultiplicity, reco::PFJet::chargedHadronMultiplicity(), pat::Jet::chargedHadronMultiplicity(), reco::btag::TrackIPData::closestToJetAxis, data, deltaR(), HiRegitMuonDetachedTripletStep_cff::DeltaR, dir, reco::btag::TrackIPData::distanceToJetAxis, reco::btau::electronEnergyFraction, reco::PFJet::electronEnergyFraction(), pat::Jet::electronEnergyFraction(), reco::btau::electronMultiplicity, reco::PFJet::electronMultiplicity(), pat::Jet::electronMultiplicity(), reco::btau::etaRel(), reco::btau::flightDistance1dSig, reco::btau::flightDistance1dVal, reco::btau::flightDistance2dSig, reco::btau::flightDistance2dVal, reco::btau::flightDistance3dSig, reco::btau::flightDistance3dVal, flipIterate(), flipValue(), reco::btau::hadronMultiplicity, reco::btau::hadronPhotonMultiplicity, mps_fire::i, training_settings::idx, reco::TaggingVariableList::insert(), reco::btag::TrackIPData::ip2d, reco::btag::IP2DSig, reco::btag::TrackIPData::ip3d, electrons_cff::ip3d, reco::btag::IP3DSig, edm::RefToBase< T >::isNonnull(), pat::Jet::isPFJet(), metsig::jet, reco::btau::jetAbsEta, reco::btau::jetEta, reco::btau::jetNSecondaryVertices, reco::btau::jetNTracks, reco::btau::jetPt, PV3DBase< T, PVType, FrameType >::mag2(), reco::btau::massVertexEnergyFraction, reco::btau::muonEnergyFraction, reco::PFJet::muonEnergyFraction(), pat::Jet::muonEnergyFraction(), reco::btau::muonMultiplicity, reco::PFJet::muonMultiplicity(), pat::Jet::muonMultiplicity(), reco::PFJet::neutralHadronEnergyFraction(), reco::btau::neutralHadronEnergyFraction, pat::Jet::neutralHadronEnergyFraction(), reco::btau::neutralHadronMultiplicity, reco::PFJet::neutralHadronMultiplicity(), pat::Jet::neutralHadronMultiplicity(), reco::btag::Vertices::NoVertex, reco::TrackKinematics::numberOfTracks(), convertSQLiteXML::ok, reco::btau::photonEnergyFraction, reco::PFJet::photonEnergyFraction(), pat::Jet::photonEnergyFraction(), reco::btau::photonMultiplicity, reco::PFJet::photonMultiplicity(), pat::Jet::photonMultiplicity(), reco::ParticleMasses::piPlus, pseudoMultiplicityMin, reco::btag::Vertices::PseudoVertex, pseudoVertexV0Filter, MetAnalyzer::pv(), range_for, reco::btag::Vertices::RecoVertex, Measurement1D::significance(), sortCriterium, mathSSE::sqrt(), HGCalGeometryMode::Square, threshTrack(), reco::btau::totalMultiplicity, HiIsolationCommonParameters_cff::track, reco::btau::trackDecayLenVal, reco::btau::trackDeltaR, reco::btau::trackEta, reco::btau::trackEtaRel, reco::btau::trackJetDistVal, reco::btau::trackJetPt, reco::btau::trackMomentum, trackMultiplicityMin, trackPairV0Filter, reco::btau::trackPPar, reco::btau::trackPParRatio, trackPseudoSelector, reco::btau::trackPtRatio, reco::btau::trackPtRel, l1t::tracks, trackSelector, reco::btau::trackSip2dSig, reco::btau::trackSip2dSigAboveCharm, reco::btau::trackSip2dVal, reco::btau::trackSip2dValAboveCharm, reco::btau::trackSip3dSig, reco::btau::trackSip3dSigAboveCharm, reco::btau::trackSip3dVal, reco::btau::trackSip3dValAboveCharm, reco::btau::trackSumJetDeltaR, reco::btau::trackSumJetEtRatio, useTrackWeights, Measurement1D::value(), reco::TrackKinematics::vectorSum(), reco::btau::vertexBoostOverSqrtJetPt, reco::btau::vertexCategory, reco::btau::vertexEnergyRatio, vertexFlip, reco::btau::vertexJetDeltaR, reco::btau::vertexMass, vertexMassCorrection, reco::btau::vertexNTracks, badGlobalMuonTaggersAOD_cff::vtx, reco::TrackKinematics::weightedVectorSum(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by operator()().

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  vars.insert(btau::jetAbsEta, fabs(jet->eta()), true);
120 
121  if (ipInfo.selectedTracks().size() < trackMultiplicityMin)
122  return;
123 
124  vars.insert(btau::jetNTracks, ipInfo.selectedTracks().size(), true);
125 
126  TrackKinematics allKinematics;
127  TrackKinematics trackJetKinematics;
128 
129  double jet_track_ESum= 0.;
130 
131  int vtx = -1;
132 
133  IterationRange range = flipIterate(svInfo.nVertices(), true);
134  range_for(i , range) {
135  if (vtx < 0) vtx = i;
136  }
137 
138  if (vtx >= 0) {
139  vtxType = btag::Vertices::RecoVertex;
140  vars.insert(btau::flightDistance1dVal,flipValue(svInfo.flightDistance(vtx, 1).value(),true),true);
141  vars.insert(btau::flightDistance1dSig,flipValue(svInfo.flightDistance(vtx, 1).significance(),true),true);
142  vars.insert(btau::flightDistance2dVal,flipValue(svInfo.flightDistance(vtx, 2).value(),true),true);
143  vars.insert(btau::flightDistance2dSig,flipValue(svInfo.flightDistance(vtx, 2).significance(),true),true);
144  vars.insert(btau::flightDistance3dVal,flipValue(svInfo.flightDistance(vtx, 3).value(),true),true);
145  vars.insert(btau::flightDistance3dSig,flipValue(svInfo.flightDistance(vtx, 3).significance(),true),true);
146  vars.insert(btau::vertexJetDeltaR,Geom::deltaR(svInfo.flightDirection(vtx), vertexFlip ? -jetDir : jetDir),true);
147  vars.insert(btau::jetNSecondaryVertices, svInfo.nVertices(), true);
148  }
149 
150  std::vector<std::size_t> indices = ipInfo.sortedIndexes(sortCriterium);
151  const std::vector<reco::btag::TrackIPData> &ipData = ipInfo.impactParameterData();
152 
153  const Container &tracks = ipInfo.selectedTracks();
154  std::vector<TrackRef> pseudoVertexTracks;
155 
156  std::vector<TrackRef> trackPairV0Test(2);
157  range = flipIterate(indices.size(), false);
158  range_for(i, range) {
159  std::size_t idx = indices[i];
160  const reco::btag::TrackIPData &data = ipData[idx];
161  const TrackRef &track = tracks[idx];
162 
163  jet_track_ESum += std::sqrt(track->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
164 
165  // add track to kinematics for all tracks in jet
166  //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...
167 
168  // filter track -> this track selection can be tighter than the vertex track selection (used to fill the track related variables...)
169  if (!trackSelector(track, data, *jet, pv))
170  continue;
171 
172  // add track to kinematics for all tracks in jet
173  allKinematics.add(track);
174 
175  // if no vertex was reconstructed, attempt pseudo vertex
176  if (vtxType == btag::Vertices::NoVertex && trackPseudoSelector(track, data, *jet, pv)) {
177  pseudoVertexTracks.push_back(track);
178  vertexKinematics.add(track);
179  }
180 
181  // check against all other tracks for V0 track pairs
182  trackPairV0Test[0] = track;
183  bool ok = true;
184  range_for(j, range) {
185  if (i == j)
186  continue;
187 
188  std::size_t pairIdx = indices[j];
189  const reco::btag::TrackIPData &pairTrackData = ipData[pairIdx];
190  const TrackRef &pairTrack = tracks[pairIdx];
191 
192  if (!trackSelector(pairTrack, pairTrackData, *jet, pv))
193  continue;
194 
195  trackPairV0Test[1] = pairTrack;
196  if (!trackPairV0Filter(trackPairV0Test)) {
197  ok = false;
198  break;
199  }
200  }
201  if (!ok)
202  continue;
203 
204  trackJetKinematics.add(track);
205 
206  // add track variables
207  math::XYZVector trackMom = track->momentum();
208  double trackMag = std::sqrt(trackMom.Mag2());
209 
210  vars.insert(btau::trackSip3dVal, flipValue(data.ip3d.value(), false), true);
211  vars.insert(btau::trackSip3dSig, flipValue(data.ip3d.significance(), false), true);
212  vars.insert(btau::trackSip2dVal, flipValue(data.ip2d.value(), false), true);
213  vars.insert(btau::trackSip2dSig, flipValue(data.ip2d.significance(), false), true);
214  vars.insert(btau::trackJetDistVal, data.distanceToJetAxis.value(), true);
215 // vars.insert(btau::trackJetDistSig, data.distanceToJetAxis.significance(), true);
216 // vars.insert(btau::trackFirstTrackDist, data.distanceToFirstTrack, true);
217 // vars.insert(btau::trackGhostTrackVal, data.distanceToGhostTrack.value(), true);
218 // vars.insert(btau::trackGhostTrackSig, data.distanceToGhostTrack.significance(), true);
219  vars.insert(btau::trackDecayLenVal, havePv ? (data.closestToJetAxis - pv).mag() : -1.0, true);
220 
221  vars.insert(btau::trackMomentum, trackMag, true);
222  vars.insert(btau::trackEta, trackMom.Eta(), true);
223 
224  vars.insert(btau::trackPtRel, VectorUtil::Perp(trackMom, jetDir), true);
225  vars.insert(btau::trackPPar, jetDir.Dot(trackMom), true);
226  vars.insert(btau::trackDeltaR, VectorUtil::DeltaR(trackMom, jetDir), true);
227  vars.insert(btau::trackPtRatio, VectorUtil::Perp(trackMom, jetDir) / trackMag, true);
228  vars.insert(btau::trackPParRatio, jetDir.Dot(trackMom) / trackMag, true);
229  }
230 
231  if (vtxType == btag::Vertices::NoVertex && vertexKinematics.numberOfTracks() >= pseudoMultiplicityMin && pseudoVertexV0Filter(pseudoVertexTracks))
232  {
233  vtxType = btag::Vertices::PseudoVertex;
234  for(typename std::vector<TrackRef>::const_iterator trkIt = pseudoVertexTracks.begin(); trkIt != pseudoVertexTracks.end(); ++trkIt)
235  {
236  vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir,(*trkIt)->momentum()), true);
237  vtx_track_ptSum += std::sqrt((*trkIt)->momentum().Perp2());
238  vtx_track_ESum += std::sqrt((*trkIt)->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
239  }
240  }
241 
242  vars.insert(btau::vertexCategory, vtxType, true);
243 
244  vars.insert(btau::trackJetPt, trackJetKinematics.vectorSum().Pt(), true);
245  vars.insert(btau::trackSumJetDeltaR,VectorUtil::DeltaR(allKinematics.vectorSum(), jetDir), true);
246  vars.insert(btau::trackSumJetEtRatio,allKinematics.vectorSum().Et() / ipInfo.jet()->et(), true);
247 
248  vars.insert(btau::trackSip3dSigAboveCharm, flipValue(threshTrack(ipInfo, reco::btag::IP3DSig, *jet, pv).ip3d.significance(),false),true);
249  vars.insert(btau::trackSip3dValAboveCharm, flipValue(threshTrack(ipInfo, reco::btag::IP3DSig, *jet, pv).ip3d.value(),false),true);
250  vars.insert(btau::trackSip2dSigAboveCharm, flipValue(threshTrack(ipInfo, reco::btag::IP2DSig, *jet, pv).ip2d.significance(),false),true);
251  vars.insert(btau::trackSip2dValAboveCharm, flipValue(threshTrack(ipInfo, reco::btag::IP2DSig, *jet, pv).ip2d.value(),false),true);
252 
253  if (vtxType != btag::Vertices::NoVertex) {
254  math::XYZTLorentzVector allSum = useTrackWeights
255  ? allKinematics.weightedVectorSum()
256  : allKinematics.vectorSum();
257  math::XYZTLorentzVector vertexSum = useTrackWeights
258  ? vertexKinematics.weightedVectorSum()
259  : vertexKinematics.vectorSum();
260 
261  if (vtxType != btag::Vertices::RecoVertex) {
262  vars.insert(btau::vertexNTracks,vertexKinematics.numberOfTracks(), true);
263  vars.insert(btau::vertexJetDeltaR,VectorUtil::DeltaR(vertexSum, jetDir), true);
264  }
265 
266  double vertexMass = vertexSum.M();
267  if (vtxType == btag::Vertices::RecoVertex &&
268  vertexMassCorrection) {
269  const GlobalVector& dir = svInfo.flightDirection(vtx);
270  double vertexPt2 = math::XYZVector(dir.x(), dir.y(), dir.z()).Cross(vertexSum).Mag2() / dir.mag2();
271  vertexMass = std::sqrt(vertexMass * vertexMass + vertexPt2) + std::sqrt(vertexPt2);
272  }
273  vars.insert(btau::vertexMass, vertexMass, true);
274 
275  double varPi = (vertexMass/5.2794) * (vtx_track_ESum /jet_track_ESum); // 5.2794 should be the average B meson mass of PDG! CHECK!!!
276  vars.insert(btau::massVertexEnergyFraction, varPi / (varPi + 0.04), true);
277  double varB = (std::sqrt(5.2794) * vtx_track_ptSum) / ( vertexMass * std::sqrt(jet->pt()));
278  vars.insert(btau::vertexBoostOverSqrtJetPt,varB*varB/(varB*varB + 10.), true);
279 
280  if (allKinematics.numberOfTracks()) {
281  vars.insert(btau::vertexEnergyRatio, vertexSum.E() / allSum.E(), true);
282  }
283  else {
284  vars.insert(btau::vertexEnergyRatio, 1, true);
285  }
286  }
287 
288  reco::PFJet const * pfJet = dynamic_cast<reco::PFJet const *>( &* jet ) ;
289  pat::Jet const * patJet = dynamic_cast<pat::Jet const *>( &* jet ) ;
290  if ( pfJet != nullptr )
291  {
292  vars.insert(btau::chargedHadronEnergyFraction,pfJet->chargedHadronEnergyFraction(), true);
293  vars.insert(btau::neutralHadronEnergyFraction,pfJet->neutralHadronEnergyFraction(), true);
294  vars.insert(btau::photonEnergyFraction,pfJet->photonEnergyFraction(), true);
295  vars.insert(btau::electronEnergyFraction,pfJet->electronEnergyFraction(), true);
296  vars.insert(btau::muonEnergyFraction,pfJet->muonEnergyFraction(), true);
297  vars.insert(btau::chargedHadronMultiplicity,pfJet->chargedHadronMultiplicity(), true);
298  vars.insert(btau::neutralHadronMultiplicity,pfJet->neutralHadronMultiplicity(), true);
299  vars.insert(btau::photonMultiplicity,pfJet->photonMultiplicity(), true);
300  vars.insert(btau::electronMultiplicity,pfJet->electronMultiplicity(), true);
301  vars.insert(btau::muonMultiplicity,pfJet->muonMultiplicity(), true);
302  vars.insert(btau::hadronMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity(), true);
303  vars.insert(btau::hadronPhotonMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity()+pfJet->photonMultiplicity(), true);
304  vars.insert(btau::totalMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity()+pfJet->photonMultiplicity()+pfJet->electronMultiplicity()+pfJet->muonMultiplicity(), true);
305 
306  }
307  else if( patJet != nullptr && patJet->isPFJet() )
308  {
309  vars.insert(btau::chargedHadronEnergyFraction,patJet->chargedHadronEnergyFraction(), true);
310  vars.insert(btau::neutralHadronEnergyFraction,patJet->neutralHadronEnergyFraction(), true);
311  vars.insert(btau::photonEnergyFraction,patJet->photonEnergyFraction(), true);
312  vars.insert(btau::electronEnergyFraction,patJet->electronEnergyFraction(), true);
313  vars.insert(btau::muonEnergyFraction,patJet->muonEnergyFraction(), true);
314  vars.insert(btau::chargedHadronMultiplicity,patJet->chargedHadronMultiplicity(), true);
315  vars.insert(btau::neutralHadronMultiplicity,patJet->neutralHadronMultiplicity(), true);
316  vars.insert(btau::photonMultiplicity,patJet->photonMultiplicity(), true);
317  vars.insert(btau::electronMultiplicity,patJet->electronMultiplicity(), true);
318  vars.insert(btau::muonMultiplicity,patJet->muonMultiplicity(), true);
319  vars.insert(btau::hadronMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity(), true);
320  vars.insert(btau::hadronPhotonMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity()+patJet->photonMultiplicity(), true);
321  vars.insert(btau::totalMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity()+patJet->photonMultiplicity()+patJet->electronMultiplicity()+patJet->muonMultiplicity(), true);
322 
323  }
324  else
325  {
326  vars.insert(btau::chargedHadronEnergyFraction,0., true);
327  vars.insert(btau::neutralHadronEnergyFraction,0., true);
328  vars.insert(btau::photonEnergyFraction,0., true);
329  vars.insert(btau::electronEnergyFraction,0., true);
330  vars.insert(btau::muonEnergyFraction,0., true);
331  vars.insert(btau::chargedHadronMultiplicity,0, true);
332  vars.insert(btau::neutralHadronMultiplicity,0, true);
333  vars.insert(btau::photonMultiplicity,0, true);
334  vars.insert(btau::electronMultiplicity,0, true);
335  vars.insert(btau::muonMultiplicity,0, true);
336  vars.insert(btau::hadronMultiplicity,0, true);
337  vars.insert(btau::hadronPhotonMultiplicity,0, true);
338  vars.insert(btau::totalMultiplicity,0, true);
339  }
340 }
CombinedSVComputer::trackSelector
reco::TrackSelector trackSelector
Definition: CombinedSVComputer.h:81
reco::ParticleMasses::piPlus
const double piPlus
Definition: ParticleMasses.h:9
PV3DBase::mag2
T mag2() const
Definition: PV3DBase.h:66
reco::PFJet::photonMultiplicity
int photonMultiplicity() const
photonMultiplicity
Definition: PFJet.h:131
reco::TrackKinematics::weightedVectorSum
const math::XYZTLorentzVector & weightedVectorSum() const
Definition: TrackKinematics.h:46
pat::Jet::neutralHadronEnergyFraction
float neutralHadronEnergyFraction() const
neutralHadronEnergyFraction (relative to uncorrected jet energy)
Definition: Jet.h:374
mps_fire.i
i
Definition: mps_fire.py:269
pat::Jet::photonEnergyFraction
float photonEnergyFraction() const
photonEnergyFraction (relative to corrected jet energy)
Definition: Jet.h:384
pat::Jet::electronMultiplicity
int electronMultiplicity() const
electronMultiplicity
Definition: Jet.h:409
CombinedSVComputer::pseudoMultiplicityMin
unsigned int pseudoMultiplicityMin
Definition: CombinedSVComputer.h:84
pat::Jet::chargedHadronEnergyFraction
float chargedHadronEnergyFraction() const
chargedHadronEnergyFraction (relative to uncorrected jet energy)
Definition: Jet.h:372
reco::TrackKinematics::add
void add(const reco::Track &track, double weight=1.0)
Definition: TrackKinematics.cc:77
pat::Jet::photonMultiplicity
int photonMultiplicity() const
photonMultiplicity
Definition: Jet.h:407
reco::PFJet::chargedHadronEnergyFraction
float chargedHadronEnergyFraction() const
chargedHadronEnergyFraction
Definition: PFJet.h:100
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::pseudoVertexV0Filter
reco::V0Filter pseudoVertexV0Filter
Definition: CombinedSVComputer.h:89
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
PV3DBase::y
T y() const
Definition: PV3DBase.h:63
pat::Jet::muonMultiplicity
int muonMultiplicity() const
muonMultiplicity
Definition: Jet.h:677
edm::RefToBase::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: RefToBase.h:337
pat::Jet::chargedHadronMultiplicity
int chargedHadronMultiplicity() const
chargedHadronMultiplicity
Definition: Jet.h:403
electrons_cff.ip3d
ip3d
Definition: electrons_cff.py:309
reco::PFJet::photonEnergyFraction
float photonEnergyFraction() const
photonEnergyFraction
Definition: PFJet.h:108
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
HiRegitMuonDetachedTripletStep_cff.DeltaR
DeltaR
Definition: HiRegitMuonDetachedTripletStep_cff.py:22
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:6
reco::PFJet::neutralHadronMultiplicity
int neutralHadronMultiplicity() const
neutralHadronMultiplicity
Definition: PFJet.h:129
reco::PFJet::neutralHadronEnergyFraction
float neutralHadronEnergyFraction() const
neutralHadronEnergyFraction
Definition: PFJet.h:104
reco::btag::TrackIPData::ip3d
Measurement1D ip3d
Definition: IPTagInfo.h:32
CombinedSVComputer::flipIterate
IterationRange flipIterate(int size, bool vertex) const
Definition: CombinedSVComputer.cc:37
pat::Jet::isPFJet
bool isPFJet() const
check to see if the jet is a reco::PFJet
Definition: Jet.h:255
CombinedSVComputer::trackPairV0Filter
reco::V0Filter trackPairV0Filter
Definition: CombinedSVComputer.h:90
deltaR
double deltaR(double eta1, double eta2, double phi1, double phi2)
Definition: TreeUtility.cc:17
Measurement1D::significance
double significance() const
Definition: Measurement1D.h:32
reco::TrackKinematics::numberOfTracks
unsigned int numberOfTracks() const
Definition: TrackKinematics.h:41
pat::Jet::electronEnergyFraction
float electronEnergyFraction() const
electronEnergyFraction (relative to corrected jet energy)
Definition: Jet.h:388
range_for
#define range_for(i, x)
Definition: CombinedSVComputer.h:38
reco::btag::TrackIPData::closestToJetAxis
GlobalPoint closestToJetAxis
Definition: IPTagInfo.h:29
HiIsolationCommonParameters_cff.track
track
Definition: HiIsolationCommonParameters_cff.py:9
math::XYZVector
XYZVectorD XYZVector
spatial vector with cartesian internal representation
Definition: Vector3D.h:30
CombinedSVComputer::flipValue
double flipValue(double value, bool vertex) const
Definition: CombinedSVComputer.cc:32
training_settings.idx
idx
Definition: training_settings.py:16
reco::TrackRef
edm::Ref< TrackCollection > TrackRef
persistent reference to a Track
Definition: TrackFwd.h:20
reco::PFJet::electronEnergyFraction
float electronEnergyFraction() const
electronEnergyFraction
Definition: PFJet.h:112
pat::Jet
Analysis-level calorimeter jet class.
Definition: Jet.h:80
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::PFJet::chargedHadronMultiplicity
int chargedHadronMultiplicity() const
chargedHadronMultiplicity
Definition: PFJet.h:127
reco::btag::TrackIPData::distanceToJetAxis
Measurement1D distanceToJetAxis
Definition: IPTagInfo.h:33
reco::PFJet::muonMultiplicity
int muonMultiplicity() const
muonMultiplicity
Definition: PFJet.h:135
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:43
data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:82
pat::Jet::neutralHadronMultiplicity
int neutralHadronMultiplicity() const
neutralHadronMultiplicity
Definition: Jet.h:405
reco::TrackKinematics::vectorSum
const math::XYZTLorentzVector & vectorSum() const
Definition: TrackKinematics.h:44
badGlobalMuonTaggersAOD_cff.vtx
vtx
Definition: badGlobalMuonTaggersAOD_cff.py:5
pat::Jet::muonEnergyFraction
float muonEnergyFraction() const
muonEnergyFraction (relative to corrected jet energy)
Definition: Jet.h:392
dir
dbl *** dir
Definition: mlp_gen.cc:35
reco::PFJet::muonEnergyFraction
float muonEnergyFraction() const
muonEnergyFraction
Definition: PFJet.h:116
PV3DBase::x
T x() const
Definition: PV3DBase.h:62
reco::JetExtendedAssociation::Container
edm::AssociationVector< reco::JetRefBaseProd, Values > Container
Definition: JetExtendedAssociation.h:29
reco::PFJet::electronMultiplicity
int electronMultiplicity() const
electronMultiplicity
Definition: PFJet.h:133
reco::TaggingVariableList::insert
void insert(const TaggingVariable &variable, bool delayed=false)
Definition: TaggingVariable.cc:294
CombinedSVComputer::trackMultiplicityMin
unsigned int trackMultiplicityMin
Definition: CombinedSVComputer.h:85
CombinedSVComputer::IterationRange CombinedSVComputer::flipIterate ( int  size,
bool  vertex 
) const
inline

Definition at line 37 of file CombinedSVComputer.cc.

References CombinedSVComputer::IterationRange::begin, charmCut, data, CombinedSVComputer::IterationRange::end, mps_fire::i, training_settings::idx, reco::IPTagInfo< Container, Base >::impactParameterData(), CombinedSVComputer::IterationRange::increment, metsig::jet, MetAnalyzer::pv(), range_for, reco::IPTagInfo< Container, Base >::selectedTracks(), findQualityFiles::size, reco::IPTagInfo< Container, Base >::sortedIndexes(), threshTrack(), HiIsolationCommonParameters_cff::track, trackFlip, trackNoDeltaRSelector, l1t::tracks, and vertexFlip.

Referenced by fillCommonVariables(), and operator()().

39 {
40  IterationRange range;
41  if (vertex ? vertexFlip : trackFlip) {
42  range.begin = size - 1;
43  range.end = -1;
44  range.increment = -1;
45  } else {
46  range.begin = 0;
47  range.end = size;
48  range.increment = +1;
49  }
50 
51  return range;
52 }
findQualityFiles.size
size
Write out results.
Definition: findQualityFiles.py:441
double CombinedSVComputer::flipValue ( double  value,
bool  vertex 
) const
inline

Definition at line 32 of file CombinedSVComputer.cc.

References trackFlip, relativeConstraints::value, and vertexFlip.

Referenced by fillCommonVariables().

33 {
34  return (vertex ? vertexFlip : trackFlip) ? -value : value;
35 }
value
Definition: value.py:1
TaggingVariableList CombinedSVComputer::operator() ( const reco::TrackIPTagInfo &  ipInfo,
const reco::SecondaryVertexTagInfo &  svInfo 
) const
virtual

Definition at line 164 of file CombinedSVComputer.cc.

References reco::TrackKinematics::add(), reco::btau::etaRel(), fillCommonVariables(), reco::TaggingVariableList::finalize(), flipIterate(), reco::Vertex::hasRefittedTracks(), mps_fire::i, reco::TaggingVariableList::insert(), minTrackWeight, reco::TrackBase::momentum(), nTracks(), reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::nVertices(), reco::ParticleMasses::piPlus, range_for, reco::Vertex::refittedTrack(), reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::secondaryVertex(), mathSSE::sqrt(), HGCalGeometryMode::Square, HiIsolationCommonParameters_cff::track, reco::btau::trackEtaRel, reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), reco::Vertex::trackWeight(), reco::btau::vertexFitProb, reco::btau::vertexNTracks, badGlobalMuonTaggersAOD_cff::vtx, and w.

Referenced by CombinedSVSoftLeptonComputer::operator()().

166 {
167  using namespace ROOT::Math;
168 
169  edm::RefToBase<Jet> jet = ipInfo.jet();
170  math::XYZVector jetDir = jet->momentum().Unit();
171  TaggingVariableList vars;
172 
173  TrackKinematics vertexKinematics;
174 
175  double vtx_track_ptSum = 0.;
176  double vtx_track_ESum = 0.;
177 
178  // the following is specific depending on the type of vertex
179  int vtx = -1;
180  unsigned int numberofvertextracks = 0;
181 
182  IterationRange range = flipIterate(svInfo.nVertices(), true);
183  range_for(i, range) {
184 
185  numberofvertextracks = numberofvertextracks + (svInfo.secondaryVertex(i)).nTracks();
186 
187  const Vertex &vertex = svInfo.secondaryVertex(i);
188  bool hasRefittedTracks = vertex.hasRefittedTracks();
189  for(reco::Vertex::trackRef_iterator track = vertex.tracks_begin(); track != vertex.tracks_end(); track++) {
190  double w = vertex.trackWeight(*track);
191  if (w < minTrackWeight)
192  continue;
193  if (hasRefittedTracks) {
194  const Track actualTrack = vertex.refittedTrack(*track);
195  vertexKinematics.add(actualTrack, w);
196  vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir,actualTrack.momentum()), true);
197  if(vtx < 0) // calculate this only for the first vertex
198  {
199  vtx_track_ptSum += std::sqrt(actualTrack.momentum().Perp2());
200  vtx_track_ESum += std::sqrt(actualTrack.momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
201  }
202  } else {
203  vertexKinematics.add(**track, w);
204  vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir,(*track)->momentum()), true);
205  if(vtx < 0) // calculate this only for the first vertex
206  {
207  vtx_track_ptSum += std::sqrt((*track)->momentum().Perp2());
208  vtx_track_ESum += std::sqrt((*track)->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
209  }
210  }
211  }
212 
213  if (vtx < 0) vtx = i;
214  }
215  if(vtx>=0){
216  vars.insert(btau::vertexNTracks, numberofvertextracks, true);
217  vars.insert(btau::vertexFitProb,(svInfo.secondaryVertex(vtx)).normalizedChi2(), true);
218  }
219 
220  // after we collected vertex information we let the common code complete the job
221  fillCommonVariables(vars,vertexKinematics,ipInfo,svInfo,vtx_track_ptSum,vtx_track_ESum);
222 
223  vars.finalize();
224  return vars;
225 }
reco::ParticleMasses::piPlus
const double piPlus
Definition: ParticleMasses.h:9
nTracks
const unsigned int nTracks(const reco::Vertex &sv)
Definition: TemplatedVertexArbitrator.h:48
mps_fire.i
i
Definition: mps_fire.py:269
w
const double w
Definition: UKUtility.cc:23
reco::Vertex::tracks_end
trackRef_iterator tracks_end() const
last iterator over tracks
Definition: Vertex.cc:81
reco::TrackKinematics::add
void add(const reco::Track &track, double weight=1.0)
Definition: TrackKinematics.cc:77
reco::TemplatedSecondaryVertexTagInfo::secondaryVertex
const VTX & secondaryVertex(unsigned int index) const
Definition: TemplatedSecondaryVertexTagInfo.h:125
reco::Vertex::refittedTrack
Track refittedTrack(const TrackBaseRef &track) const
reco::btau::etaRel
double etaRel(const math::XYZVector &dir, const math::XYZVector &track)
Definition: TaggingVariable.h:23
reco::Vertex::hasRefittedTracks
bool hasRefittedTracks() const
Checks whether refitted tracks are stored.
Definition: Vertex.h:149
reco::TrackBase::momentum
const Vector & momentum() const
track momentum vector
Definition: TrackBase.h:675
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:18
reco::Vertex::trackWeight
float trackWeight(const TREF &r) const
returns the weight with which a Track has contributed to the vertex-fit.
Definition: Vertex.h:81
CombinedSVComputer::flipIterate
IterationRange flipIterate(int size, bool vertex) const
Definition: CombinedSVComputer.cc:37
range_for
#define range_for(i, x)
Definition: CombinedSVComputer.h:38
HiIsolationCommonParameters_cff.track
track
Definition: HiIsolationCommonParameters_cff.py:9
math::XYZVector
XYZVectorD XYZVector
spatial vector with cartesian internal representation
Definition: Vector3D.h:30
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
reco::Vertex::trackRef_iterator
std::vector< TrackBaseRef >::const_iterator trackRef_iterator
The iteratator for the vector<TrackRef>
Definition: Vertex.h:37
badGlobalMuonTaggersAOD_cff.vtx
vtx
Definition: badGlobalMuonTaggersAOD_cff.py:5
reco::Vertex::tracks_begin
trackRef_iterator tracks_begin() const
first iterator over tracks
Definition: Vertex.cc:76
reco::TaggingVariableList::insert
void insert(const TaggingVariable &variable, bool delayed=false)
Definition: TaggingVariable.cc:294
TaggingVariableList CombinedSVComputer::operator() ( const reco::CandIPTagInfo &  ipInfo,
const reco::CandSecondaryVertexTagInfo &  svInfo 
) const
virtual

Definition at line 228 of file CombinedSVComputer.cc.

References reco::TrackKinematics::add(), reco::CompositePtrCandidate::daughterPtrVector(), reco::btau::etaRel(), fillCommonVariables(), reco::TaggingVariableList::finalize(), flipIterate(), mps_fire::i, reco::TaggingVariableList::insert(), reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::nVertices(), reco::ParticleMasses::piPlus, range_for, reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::secondaryVertex(), mathSSE::sqrt(), HGCalGeometryMode::Square, HiIsolationCommonParameters_cff::track, reco::btau::trackEtaRel, l1t::tracks, reco::btau::vertexFitProb, reco::btau::vertexNTracks, and badGlobalMuonTaggersAOD_cff::vtx.

230 {
231  using namespace ROOT::Math;
232 
233  edm::RefToBase<Jet> jet = ipInfo.jet();
234  math::XYZVector jetDir = jet->momentum().Unit();
235  TaggingVariableList vars;
236 
237  TrackKinematics vertexKinematics;
238 
239  double vtx_track_ptSum = 0.;
240  double vtx_track_ESum = 0.;
241 
242  // the following is specific depending on the type of vertex
243  int vtx = -1;
244  unsigned int numberofvertextracks = 0;
245 
246  IterationRange range = flipIterate(svInfo.nVertices(), true);
247  range_for(i, range) {
248 
249  numberofvertextracks = numberofvertextracks + (svInfo.secondaryVertex(i)).numberOfSourceCandidatePtrs();
250 
251  const reco::VertexCompositePtrCandidate &vertex = svInfo.secondaryVertex(i);
252  const std::vector<CandidatePtr> & tracks = vertex.daughterPtrVector();
253  for(std::vector<CandidatePtr>::const_iterator track = tracks.begin(); track != tracks.end(); ++track) {
254  vertexKinematics.add(*track);
255  vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir,(*track)->momentum()), true);
256  if(vtx < 0) // calculate this only for the first vertex
257  {
258  vtx_track_ptSum += std::sqrt((*track)->momentum().Perp2());
259  vtx_track_ESum += std::sqrt((*track)->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
260  }
261  }
262 
263  if (vtx < 0) vtx = i;
264  }
265  if(vtx>=0){
266  vars.insert(btau::vertexNTracks, numberofvertextracks, true);
267  vars.insert(btau::vertexFitProb,(svInfo.secondaryVertex(vtx)).vertexNormalizedChi2(), true);
268  }
269 
270  // after we collected vertex information we let the common code complete the job
271  fillCommonVariables(vars,vertexKinematics,ipInfo,svInfo,vtx_track_ptSum,vtx_track_ESum);
272 
273  vars.finalize();
274  return vars;
275 }
reco::ParticleMasses::piPlus
const double piPlus
Definition: ParticleMasses.h:9
mps_fire.i
i
Definition: mps_fire.py:269
reco::TrackKinematics::add
void add(const reco::Track &track, double weight=1.0)
Definition: TrackKinematics.cc:77
reco::TemplatedSecondaryVertexTagInfo::secondaryVertex
const VTX & secondaryVertex(unsigned int index) const
Definition: TemplatedSecondaryVertexTagInfo.h:125
reco::btau::etaRel
double etaRel(const math::XYZVector &dir, const math::XYZVector &track)
Definition: TaggingVariable.h:23
reco::CompositePtrCandidate::daughterPtrVector
virtual const daughters & daughterPtrVector() const
references to daughtes
Definition: CompositePtrCandidate.h:55
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:18
CombinedSVComputer::flipIterate
IterationRange flipIterate(int size, bool vertex) const
Definition: CombinedSVComputer.cc:37
range_for
#define range_for(i, x)
Definition: CombinedSVComputer.h:38
HiIsolationCommonParameters_cff.track
track
Definition: HiIsolationCommonParameters_cff.py:9
math::XYZVector
XYZVectorD XYZVector
spatial vector with cartesian internal representation
Definition: Vector3D.h:30
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
badGlobalMuonTaggersAOD_cff.vtx
vtx
Definition: badGlobalMuonTaggersAOD_cff.py:5
reco::TaggingVariableList::insert
void insert(const TaggingVariable &variable, bool delayed=false)
Definition: TaggingVariable.cc:294
const reco::btag::TrackIPData& CombinedSVComputer::threshTrack ( const reco::CandIPTagInfo &  trackIPTagInfo,
const reco::btag::SortCriteria  sort,
const reco::Jet &  jet,
const GlobalPoint &  pv 
) const

Referenced by fillCommonVariables(), and flipIterate().

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

Member Data Documentation

double CombinedSVComputer::charmCut
private

Definition at line 79 of file CombinedSVComputer.h.

Referenced by flipIterate().

double CombinedSVComputer::minTrackWeight
private

Definition at line 86 of file CombinedSVComputer.h.

Referenced by operator()().

unsigned int CombinedSVComputer::pseudoMultiplicityMin
private

Definition at line 84 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

reco::V0Filter CombinedSVComputer::pseudoVertexV0Filter
private

Definition at line 89 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

reco::btag::SortCriteria CombinedSVComputer::sortCriterium
private

Definition at line 80 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

std::vector<reco::btau::TaggingVariableName> CombinedSVComputer::taggingVariables
private

Definition at line 91 of file CombinedSVComputer.h.

bool CombinedSVComputer::trackFlip
private

Definition at line 77 of file CombinedSVComputer.h.

Referenced by flipIterate(), and flipValue().

unsigned int CombinedSVComputer::trackMultiplicityMin
private

Definition at line 85 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

reco::TrackSelector CombinedSVComputer::trackNoDeltaRSelector
private

Definition at line 82 of file CombinedSVComputer.h.

Referenced by flipIterate().

reco::V0Filter CombinedSVComputer::trackPairV0Filter
private

Definition at line 90 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

reco::TrackSelector CombinedSVComputer::trackPseudoSelector
private

Definition at line 83 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

reco::TrackSelector CombinedSVComputer::trackSelector
private

Definition at line 81 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

bool CombinedSVComputer::useTrackWeights
private

Definition at line 87 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

bool CombinedSVComputer::vertexFlip
private

Definition at line 78 of file CombinedSVComputer.h.

Referenced by fillCommonVariables(), flipIterate(), and flipValue().

bool CombinedSVComputer::vertexMassCorrection
private

Definition at line 88 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

Generated for CMSSW Reference Manual by doxygen 1.8.11