CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Classes | Public Member Functions | Private Member Functions | Private Attributes
CombinedSVSoftLeptonComputer Class Reference

#include <CombinedSVSoftLeptonComputer.h>

Classes

struct  IterationRange
 

Public Member Functions

 CombinedSVSoftLeptonComputer (const edm::ParameterSet &params)
 
reco::TaggingVariableList operator() (const reco::TrackIPTagInfo &ipInfo, const reco::SecondaryVertexTagInfo &svInfo, const reco::SoftLeptonTagInfo &muonInfo, const reco::SoftLeptonTagInfo &elecInfo) const
 

Private Member Functions

IterationRange flipIterate (int size, bool vertex) const
 
double flipValue (double value, bool vertex) const
 
const
reco::TrackIPTagInfo::TrackIPData & 		threshTrack (const reco::TrackIPTagInfo &trackIPTagInfo, const reco::TrackIPTagInfo::SortCriteria sort, const reco::Jet &jet, const GlobalPoint &pv) const
 

Private Attributes

double charmCut
 
double minTrackWeight
 
unsigned int pseudoMultiplicityMin
 
reco::V0Filter pseudoVertexV0Filter
 
reco::TrackIPTagInfo::SortCriteria sortCriterium
 
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 15 of file CombinedSVSoftLeptonComputer.h.

Constructor & Destructor Documentation

CombinedSVSoftLeptonComputer::CombinedSVSoftLeptonComputer ( const edm::ParameterSet &  params)

Definition at line 56 of file CombinedSVSoftLeptonComputer.cc.

56  :
57  trackFlip(params.getParameter<bool>("trackFlip")),
58  vertexFlip(params.getParameter<bool>("vertexFlip")),
59  charmCut(params.getParameter<double>("charmCut")),
60  sortCriterium(TrackSorting::getCriterium(params.getParameter<std::string>("trackSort"))),
61  trackSelector(params.getParameter<edm::ParameterSet>("trackSelection")),
62  trackNoDeltaRSelector(dropDeltaR(params.getParameter<edm::ParameterSet>("trackSelection"))),
63  trackPseudoSelector(params.getParameter<edm::ParameterSet>("trackPseudoSelection")),
64  pseudoMultiplicityMin(params.getParameter<unsigned int>("pseudoMultiplicityMin")),
65  trackMultiplicityMin(params.getParameter<unsigned int>("trackMultiplicityMin")),
66  minTrackWeight(params.getParameter<double>("minimumTrackWeight")),
67  useTrackWeights(params.getParameter<bool>("useTrackWeights")),
68  vertexMassCorrection(params.getParameter<bool>("correctVertexMass")),
69  pseudoVertexV0Filter(params.getParameter<edm::ParameterSet>("pseudoVertexV0Filter")),
70  trackPairV0Filter(params.getParameter<edm::ParameterSet>("trackPairV0Filter"))
71 {
72 
73 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TrackSorting::getCriterium
reco::TrackIPTagInfo::SortCriteria getCriterium(const std::string &name)
Definition: TrackSorting.cc:11
CombinedSVSoftLeptonComputer::sortCriterium
reco::TrackIPTagInfo::SortCriteria sortCriterium
Definition: CombinedSVSoftLeptonComputer.h:40
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
dropDeltaR
static edm::ParameterSet dropDeltaR(const edm::ParameterSet &pset)
Definition: CombinedSVSoftLeptonComputer.cc:49

Member Function Documentation

CombinedSVSoftLeptonComputer::IterationRange CombinedSVSoftLeptonComputer::flipIterate ( int  size,
bool  vertex 
) const
inlineprivate

Definition at line 80 of file CombinedSVSoftLeptonComputer.cc.

References CombinedSVSoftLeptonComputer::IterationRange::begin, CombinedSVSoftLeptonComputer::IterationRange::end, CombinedSVSoftLeptonComputer::IterationRange::increment, findQualityFiles::size, trackFlip, and vertexFlip.

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

82 {
83  IterationRange range;
84  if (vertex ? vertexFlip : trackFlip) {
85  range.begin = size - 1;
86  range.end = -1;
87  range.increment = -1;
88  } else {
89  range.begin = 0;
90  range.end = size;
91  range.increment = +1;
92  }
93 
94  return range;
95 }
findQualityFiles.size
tuple size
Write out results.
Definition: findQualityFiles.py:442
double CombinedSVSoftLeptonComputer::flipValue ( double  value,
bool  vertex 
) const
inlineprivate

Definition at line 75 of file CombinedSVSoftLeptonComputer.cc.

References trackFlip, relativeConstraints::value, and vertexFlip.

Referenced by operator()().

76 {
77  return (vertex ? vertexFlip : trackFlip) ? -value : value;
78 }
TaggingVariableList CombinedSVSoftLeptonComputer::operator() ( const reco::TrackIPTagInfo &  ipInfo,
const reco::SecondaryVertexTagInfo &  svInfo,
const reco::SoftLeptonTagInfo &  muonInfo,
const reco::SoftLeptonTagInfo &  elecInfo 
) const

Definition at line 145 of file CombinedSVSoftLeptonComputer.cc.

References reco::btau::chargedHadronEnergyFraction, reco::btau::chargedHadronMultiplicity, reco::TrackIPTagInfo::TrackIPData::closestToJetAxis, data, deltaR(), reco::SoftLeptonProperties::deltaR, dir, reco::TrackIPTagInfo::TrackIPData::distanceToJetAxis, reco::btau::electronEnergyFraction, reco::btau::electronMultiplicity, reco::LeafCandidate::et(), reco::SoftLeptonProperties::etaRel, etaRel(), edm::hlt::Exception, reco::SecondaryVertexTagInfo::flightDirection(), reco::SecondaryVertexTagInfo::flightDistance(), reco::btau::flightDistance2dSig, reco::btau::flightDistance2dVal, reco::btau::flightDistance3dSig, reco::btau::flightDistance3dVal, flipIterate(), flipValue(), reco::btau::hadronMultiplicity, reco::btau::hadronPhotonMultiplicity, reco::Vertex::hasRefittedTracks(), i, customizeTrackingMonitorSeedNumber::idx, reco::TrackIPTagInfo::impactParameterData(), reco::TaggingVariableList::insert(), reco::TrackIPTagInfo::TrackIPData::ip2d, reco::TrackIPTagInfo::TrackIPData::ip3d, edm::Ref< C, T, F >::isNonnull(), j, reco::JTATagInfo::jet(), metsig::jet, reco::btau::jetEta, reco::btau::jetNSecondaryVertices, reco::btau::jetNTracks, reco::btau::jetPt, reco::btau::leptonDeltaR, reco::btau::leptonEtaRel, reco::btau::leptonPtRel, reco::btau::leptonRatio, reco::btau::leptonRatioRel, reco::SoftLeptonTagInfo::leptons(), reco::btau::leptonSip3d, PV3DBase< T, PVType, FrameType >::mag2(), reco::btau::massVertexEnergyFraction, minTrackWeight, reco::TrackBase::momentum(), reco::btau::muonEnergyFraction, reco::btau::muonMultiplicity, reco::btau::neutralHadronEnergyFraction, reco::btau::neutralHadronMultiplicity, reco::btag::Vertices::NoVertex, reco::SecondaryVertexTagInfo::nVertices(), convertSQLiteXML::ok, pfJet, reco::btau::photonEnergyFraction, reco::btau::photonMultiplicity, reco::ParticleMasses::piPlus, funct::pow(), reco::TrackIPTagInfo::primaryVertex(), reco::SoftLeptonTagInfo::properties(), pseudoMultiplicityMin, reco::btag::Vertices::PseudoVertex, pseudoVertexV0Filter, reco::SoftLeptonProperties::ptRel, range_for, reco::SoftLeptonProperties::ratio, reco::SoftLeptonProperties::ratioRel, reco::btag::Vertices::RecoVertex, reco::Vertex::refittedTrack(), reco::SecondaryVertexTagInfo::secondaryVertex(), reco::TrackIPTagInfo::selectedTracks(), Measurement1D::significance(), reco::SoftLeptonProperties::sip3d, edm::RefVector< C, T, F >::size(), sortCriterium, reco::TrackIPTagInfo::sortedIndexes(), mathSSE::sqrt(), threshTrack(), reco::btau::totalMultiplicity, reco::btau::trackDecayLenVal, reco::btau::trackDeltaR, reco::btau::trackEtaRel, reco::btau::trackJetDistVal, reco::btau::trackJetPt, trackMultiplicityMin, trackPairV0Filter, reco::btau::trackPPar, reco::btau::trackPParRatio, trackPseudoSelector, reco::btau::trackPtRatio, reco::btau::trackPtRel, testEve_cfg::tracks, reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), 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, reco::Vertex::trackWeight(), useTrackWeights, Measurement1D::value(), reco::btau::vertexBoostOverSqrtJetPt, reco::btau::vertexCategory, reco::btau::vertexEnergyRatio, reco::btau::vertexFitProb, reco::btau::vertexJetDeltaR, reco::btau::vertexLeptonCategory, reco::btau::vertexMass, vertexMassCorrection, reco::btau::vertexNTracks, w, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

150 {
151  using namespace ROOT::Math;
152 
153  edm::RefToBase<Jet> jet = ipInfo.jet();
154 
155  math::XYZVector jetDir = jet->momentum().Unit();
156  bool havePv = ipInfo.primaryVertex().isNonnull();
157  GlobalPoint pv;
158  if (havePv)
159  pv = GlobalPoint(ipInfo.primaryVertex()->x(), ipInfo.primaryVertex()->y(), ipInfo.primaryVertex()->z());
160 
161  btag::Vertices::VertexType vtxType = btag::Vertices::NoVertex;
162 
163  TaggingVariableList vars;
164 
165  vars.insert(btau::jetPt, jet->pt(), true);
166  vars.insert(btau::jetEta, jet->eta(), true);
167 
168  if (ipInfo.selectedTracks().size() < trackMultiplicityMin)
169  return vars;
170 
171  vars.insert(btau::jetNTracks, ipInfo.selectedTracks().size(), true);
172 
173  TrackKinematics allKinematics;
174  TrackKinematics vertexKinematics;
175  TrackKinematics trackJetKinematics;
176 
177  double vtx_track_ptSum= 0.;
178  double vtx_track_ESum= 0.;
179  double jet_track_ESum= 0.;
180 
181  int vtx = -1;
182  unsigned int numberofvertextracks = 0;
183 
184  //IF THERE ARE SECONDARY VERTICES THE JET FALLS IN THE RECOVERTEX CATEGORY
185  IterationRange range = flipIterate(svInfo.nVertices(), true);
186  range_for(i, range) {
187  if (vtx < 0) vtx = i; //RecoVertex category (vtx=0) if we enter at least one time in this loop!
188 
189  numberofvertextracks = numberofvertextracks + (svInfo.secondaryVertex(i)).nTracks();
190 
191  const Vertex &vertex = svInfo.secondaryVertex(i);
192  bool hasRefittedTracks = vertex.hasRefittedTracks();
193  for(reco::Vertex::trackRef_iterator track = vertex.tracks_begin(); track != vertex.tracks_end(); track++) {
194  double w = vertex.trackWeight(*track);
195  if (w < minTrackWeight)
196  continue;
197  if (hasRefittedTracks) {
198  Track actualTrack = vertex.refittedTrack(*track);
199  vars.insert(btau::trackEtaRel, etaRel(jetDir,actualTrack.momentum()), true);
200  vertexKinematics.add(actualTrack, w);
201  if(i==0)
202  {
203  math::XYZVector vtx_trackMom = actualTrack.momentum();
204  vtx_track_ptSum += std::sqrt(std::pow(vtx_trackMom.X(),2) + std::pow(vtx_trackMom.Y(),2));
205  vtx_track_ESum += std::sqrt(vtx_trackMom.Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
206  }
207  } else { //THIS ONE IS TAKEN...
208  vars.insert(btau::trackEtaRel, etaRel(jetDir,(*track)->momentum()), true);
209  vertexKinematics.add(**track, w);
210  if(i==0) // calculate this only for the first vertex
211  {
212  math::XYZVector vtx_trackMom = (*track)->momentum();
213  vtx_track_ptSum += std::sqrt(std::pow(vtx_trackMom.X(),2) + std::pow(vtx_trackMom.Y(),2));
214  vtx_track_ESum += std::sqrt(vtx_trackMom.Mag2() + std::pow(ParticleMasses::piPlus,2));
215  }
216  }
217  }
218  }
219 
220  if (vtx >= 0) {
221  vtxType = btag::Vertices::RecoVertex;
222  vars.insert(btau::flightDistance2dVal,flipValue(svInfo.flightDistance(vtx, true).value(),true),true);
223  vars.insert(btau::flightDistance2dSig,flipValue(svInfo.flightDistance(vtx, true).significance(),true),true);
224  vars.insert(btau::flightDistance3dVal,flipValue(svInfo.flightDistance(vtx, false).value(),true),true);
225  vars.insert(btau::flightDistance3dSig,flipValue(svInfo.flightDistance(vtx, false).significance(),true),true);
226  vars.insert(btau::vertexJetDeltaR,Geom::deltaR(svInfo.flightDirection(vtx), jetDir),true);
227  vars.insert(btau::jetNSecondaryVertices, svInfo.nVertices(), true);
228  vars.insert(btau::vertexNTracks, numberofvertextracks, true);
229  vars.insert(btau::vertexFitProb,(svInfo.secondaryVertex(vtx)).normalizedChi2(), true);
230  }
231 
232 
233  //NOW ATTEMPT TO RECONSTRUCT PSEUDOVERTEX!!!
234  std::vector<std::size_t> indices = ipInfo.sortedIndexes(sortCriterium);
235  const std::vector<TrackIPTagInfo::TrackIPData> &ipData = ipInfo.impactParameterData();
236  const edm::RefVector<TrackCollection> &tracks = ipInfo.selectedTracks();
237 
238  std::vector<TrackRef> pseudoVertexTracks;
239 
240  range = flipIterate(indices.size(), false);
241  range_for(i, range) {
242  std::size_t idx = indices[i];
243  const TrackIPTagInfo::TrackIPData &data = ipData[idx];
244  const TrackRef &trackRef = tracks[idx];
245  const Track &track = *trackRef;
246 
247  // if no vertex was reconstructed, attempt pseudo vertex
248  if (vtxType == btag::Vertices::NoVertex && trackPseudoSelector(track, data, *jet, pv)) {
249  pseudoVertexTracks.push_back(trackRef);
250  vertexKinematics.add(track);
251  }
252  }
253 
254  if (vtxType == btag::Vertices::NoVertex && vertexKinematics.numberOfTracks() >= pseudoMultiplicityMin && pseudoVertexV0Filter(pseudoVertexTracks))
255  {
256  vtxType = btag::Vertices::PseudoVertex;
257  for(std::vector<TrackRef>::const_iterator track = pseudoVertexTracks.begin(); track != pseudoVertexTracks.end(); ++track)
258  {
259  vars.insert(btau::trackEtaRel, etaRel(jetDir, (*track)->momentum()), true);
260  math::XYZVector vtx_trackMom = (*track)->momentum();
261  vtx_track_ptSum += std::sqrt(std::pow(vtx_trackMom.X(),2) + std::pow(vtx_trackMom.Y(),2));
262  vtx_track_ESum += std::sqrt(vtx_trackMom.Mag2() + std::pow(ParticleMasses::piPlus,2));
263  }
264  }
265 
266  vars.insert(btau::vertexCategory, vtxType, true);
267 
268 
269 
270  // do a tighter track selection to fill the variable plots...
271  TrackRef trackPairV0Test[2];
272  range = flipIterate(indices.size(), false);
273  range_for(i, range) {
274 
275  std::size_t idx = indices[i];
276  const TrackIPTagInfo::TrackIPData &data = ipData[idx];
277  const TrackRef &trackRef = tracks[idx];
278  const Track &track = *trackRef;
279 
280  jet_track_ESum += std::sqrt((track.momentum()).Mag2() + std::pow(ParticleMasses::piPlus,2));
281  // add track to kinematics for all tracks in jet
282  //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...
283 
284  // filter tracks -> this track selection can be more tight (used to fill the track related variables...)
285  if (!trackSelector(track, data, *jet, pv))
286  continue;
287 
288  // add track to kinematics for all tracks in jet
289  allKinematics.add(track);
290 
291  // check against all other tracks for K0 track pairs setting the track mass to pi+
292  trackPairV0Test[0] = tracks[idx];
293  bool ok = true;
294  range_for(j, range) {
295  if (i == j)
296  continue;
297 
298  std::size_t pairIdx = indices[j];
299  const TrackIPTagInfo::TrackIPData &pairTrackData = ipData[pairIdx];
300  const TrackRef &pairTrackRef = tracks[pairIdx];
301  const Track &pairTrack = *pairTrackRef;
302 
303  if (!trackSelector(pairTrack, pairTrackData, *jet, pv))
304  continue;
305 
306  trackPairV0Test[1] = pairTrackRef;
307  if (!trackPairV0Filter(trackPairV0Test, 2)) { //V0 filter is more tight (0.03) than the one used for the RecoVertex and PseudoVertex tracks (0.05)
308  ok = false;
309  break;
310  }
311  }
312 
313  if (!ok)
314  continue;
315 
316  trackJetKinematics.add(track);
317 
318  // add track variables
319  math::XYZVector trackMom = track.momentum();
320  double trackMag = std::sqrt(trackMom.Mag2());
321 
322  vars.insert(btau::trackSip3dVal, flipValue(data.ip3d.value(), false), true);
323  vars.insert(btau::trackSip3dSig, flipValue(data.ip3d.significance(), false), true);
324  vars.insert(btau::trackSip2dVal, flipValue(data.ip2d.value(), false), true);
325  vars.insert(btau::trackSip2dSig, flipValue(data.ip2d.significance(), false), true);
326  vars.insert(btau::trackJetDistVal, data.distanceToJetAxis.value(), true);
327  vars.insert(btau::trackDecayLenVal, havePv ? (data.closestToJetAxis - pv).mag() : -1.0, true);
328 
329  vars.insert(btau::trackPtRel, VectorUtil::Perp(trackMom, jetDir), true);
330  vars.insert(btau::trackPPar, jetDir.Dot(trackMom), true);
331  vars.insert(btau::trackDeltaR, VectorUtil::DeltaR(trackMom, jetDir), true);
332  vars.insert(btau::trackPtRatio, VectorUtil::Perp(trackMom, jetDir) / trackMag, true);
333  vars.insert(btau::trackPParRatio, jetDir.Dot(trackMom) / trackMag, true);
334  }
335 
336  vars.insert(btau::trackJetPt, trackJetKinematics.vectorSum().Pt(), true);
337 
338  vars.insert(btau::trackSumJetDeltaR,VectorUtil::DeltaR(allKinematics.vectorSum(), jetDir), true);
339  vars.insert(btau::trackSumJetEtRatio,allKinematics.vectorSum().Et() / ipInfo.jet()->et(), true);
340  vars.insert(btau::trackSip3dSigAboveCharm, flipValue(threshTrack(ipInfo, TrackIPTagInfo::IP3DSig, *jet, pv).ip3d.significance(),false),true);
341  vars.insert(btau::trackSip3dValAboveCharm, flipValue(threshTrack(ipInfo, TrackIPTagInfo::IP3DSig, *jet, pv).ip3d.value(),false),true);
342  vars.insert(btau::trackSip2dSigAboveCharm, flipValue(threshTrack(ipInfo, TrackIPTagInfo::IP2DSig, *jet, pv).ip2d.significance(),false),true);
343  vars.insert(btau::trackSip2dValAboveCharm, flipValue(threshTrack(ipInfo, TrackIPTagInfo::IP2DSig, *jet, pv).ip2d.value(),false),true);
344 
345  if (vtxType != btag::Vertices::NoVertex) {
346  math::XYZTLorentzVector allSum = useTrackWeights ? allKinematics.weightedVectorSum() : allKinematics.vectorSum();
347  math::XYZTLorentzVector vertexSum = useTrackWeights ? vertexKinematics.weightedVectorSum() : vertexKinematics.vectorSum();
348 
349  if (vtxType != btag::Vertices::RecoVertex) {
350  vars.insert(btau::vertexNTracks,vertexKinematics.numberOfTracks(), true);
351  vars.insert(btau::vertexJetDeltaR,VectorUtil::DeltaR(vertexSum, jetDir), true);
352  }
353 
354  double vertexMass = vertexSum.M();
355  double varPi = 0;
356  double varB = 0;
357  if (vtxType == btag::Vertices::RecoVertex) {
358  if(vertexMassCorrection)
359  {
360  GlobalVector dir = svInfo.flightDirection(vtx);
361  double vertexPt2 = math::XYZVector(dir.x(), dir.y(), dir.z()).Cross(vertexSum).Mag2() / dir.mag2();
362  vertexMass = std::sqrt(vertexMass * vertexMass + vertexPt2) + std::sqrt(vertexPt2);
363  }
364  }
365  vars.insert(btau::vertexMass, vertexMass, true);
366  varPi = (vertexMass/5.2794) * (vtx_track_ESum /jet_track_ESum); //5.2794 should be average B meson mass of PDG! CHECK!!!
367  vars.insert(btau::massVertexEnergyFraction, varPi, true);
368  varB = (std::sqrt(5.2794) * vtx_track_ptSum) / ( vertexMass * std::sqrt(jet->pt()));
369  vars.insert(btau::vertexBoostOverSqrtJetPt,varB*varB/(varB*varB + 10.), true);
370 
371  if (allKinematics.numberOfTracks())
372  vars.insert(btau::vertexEnergyRatio, vertexSum.E() / allSum.E(), true);
373  else
374  vars.insert(btau::vertexEnergyRatio, 1, true);
375  }
376 
377  reco::PFJet const * pfJet = dynamic_cast<reco::PFJet const *>( &* jet ) ;
378  pat::Jet const * patJet = dynamic_cast<pat::Jet const *>( &* jet ) ;
379  if ( pfJet != 0 ) {
380  vars.insert(btau::chargedHadronEnergyFraction,pfJet->chargedHadronEnergyFraction(), true);
381  vars.insert(btau::neutralHadronEnergyFraction,pfJet->neutralHadronEnergyFraction(), true);
382  vars.insert(btau::photonEnergyFraction,pfJet->photonEnergyFraction(), true);
383  vars.insert(btau::electronEnergyFraction,pfJet->electronEnergyFraction(), true);
384  vars.insert(btau::muonEnergyFraction,pfJet->muonEnergyFraction(), true);
385  vars.insert(btau::chargedHadronMultiplicity,pfJet->chargedHadronMultiplicity(), true);
386  vars.insert(btau::neutralHadronMultiplicity,pfJet->neutralHadronMultiplicity(), true);
387  vars.insert(btau::photonMultiplicity,pfJet->photonMultiplicity(), true);
388  vars.insert(btau::electronMultiplicity,pfJet->electronMultiplicity(), true);
389  vars.insert(btau::muonMultiplicity,pfJet->muonMultiplicity(), true);
390  vars.insert(btau::hadronMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity(), true);
391  vars.insert(btau::hadronPhotonMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity()+pfJet->photonMultiplicity(), true);
392  vars.insert(btau::totalMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity()+pfJet->photonMultiplicity()+pfJet->electronMultiplicity()+pfJet->muonMultiplicity(), true);
393 
394  }
395  else if( patJet != 0)
396  {
397  vars.insert(btau::chargedHadronEnergyFraction,patJet->chargedHadronEnergyFraction(), true);
398  vars.insert(btau::neutralHadronEnergyFraction,patJet->neutralHadronEnergyFraction(), true);
399  vars.insert(btau::photonEnergyFraction,patJet->photonEnergyFraction(), true);
400  vars.insert(btau::electronEnergyFraction,patJet->electronEnergyFraction(), true);
401  vars.insert(btau::muonEnergyFraction,patJet->muonEnergyFraction(), true);
402  vars.insert(btau::chargedHadronMultiplicity,patJet->chargedHadronMultiplicity(), true);
403  vars.insert(btau::neutralHadronMultiplicity,patJet->neutralHadronMultiplicity(), true);
404  vars.insert(btau::photonMultiplicity,patJet->photonMultiplicity(), true);
405  vars.insert(btau::electronMultiplicity,patJet->electronMultiplicity(), true);
406  vars.insert(btau::muonMultiplicity,patJet->muonMultiplicity(), true);
407  vars.insert(btau::hadronMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity(), true);
408  vars.insert(btau::hadronPhotonMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity()+patJet->photonMultiplicity(), true);
409  vars.insert(btau::totalMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity()+patJet->photonMultiplicity()+patJet->electronMultiplicity()+patJet->muonMultiplicity(), true);
410 
411  }
412  else
413  {
414  throw cms::Exception("InvalidConfiguration") << "From CombinedSVSoftLeptonComputer::operator: reco::PFJet OR pat::Jet are required by this module" << std::endl;
415  }
416 
417  int leptonCategory = 0; //0 = no lepton, 1 = muon, 2 = electron
418 
419  for (unsigned int i = 0; i < muonInfo.leptons(); i++) {// loop over all muons, not optimal -> find the best or use ranking from best to worst
420  leptonCategory = 1; // muon category
421  const SoftLeptonProperties & propertiesMuon = muonInfo.properties(i);
422  vars.insert(btau::leptonPtRel,propertiesMuon.ptRel , true);
423  vars.insert(btau::leptonSip3d,propertiesMuon.sip3d , true);
424  vars.insert(btau::leptonDeltaR,propertiesMuon.deltaR , true);
425  vars.insert(btau::leptonRatioRel,propertiesMuon.ratioRel , true);
426  vars.insert(btau::leptonEtaRel,propertiesMuon.etaRel , true);
427  vars.insert(btau::leptonRatio,propertiesMuon.ratio , true);
428  }
429 
430  if(leptonCategory != 1){ //no soft muon found, try soft electron
431  for (unsigned int i = 0; i < elecInfo.leptons(); i++) { // loop over all electrons, not optimal -> find the best or use ranking from best to worst
432  leptonCategory = 2; // electron category
433  const SoftLeptonProperties & propertiesElec = elecInfo.properties(i);
434  vars.insert(btau::leptonPtRel,propertiesElec.ptRel , true);
435  vars.insert(btau::leptonSip3d,propertiesElec.sip3d , true);
436  vars.insert(btau::leptonDeltaR,propertiesElec.deltaR , true);
437  vars.insert(btau::leptonRatioRel,propertiesElec.ratioRel , true);
438  vars.insert(btau::leptonEtaRel,propertiesElec.etaRel , true);
439  vars.insert(btau::leptonRatio,propertiesElec.ratio , true);
440  }
441  }
442 
443 
444  //put default value for vertexLeptonCategory on 2 = NoVertexNoSoftLepton
445  int vertexLepCat = 2;
446 
447  if(leptonCategory == 0){ // no soft lepton
448  if (vtxType == btag::Vertices::RecoVertex)
449  vertexLepCat = 0;
450  else if (vtxType == btag::Vertices::PseudoVertex)
451  vertexLepCat = 1;
452  else
453  vertexLepCat = 2;
454  } else if(leptonCategory == 1){ // soft muon
455  if (vtxType == btag::Vertices::RecoVertex)
456  vertexLepCat = 3;
457  else if(vtxType == btag::Vertices::PseudoVertex)
458  vertexLepCat = 4;
459  else vertexLepCat = 5;
460  } else if(leptonCategory == 2){ // soft electron
461  if (vtxType == btag::Vertices::RecoVertex)
462  vertexLepCat = 6;
463  else if (vtxType == btag::Vertices::PseudoVertex)
464  vertexLepCat = 7;
465  else
466  vertexLepCat = 8;
467  }
468 
469  vars.insert(btau::vertexLeptonCategory, vertexLepCat , true);
470 
471  vars.finalize();
472 
473  return vars;
474 }
i
int i
Definition: DBlmapReader.cc:9
PV3DBase::mag2
T mag2() const
Definition: PV3DBase.h:66
reco::TrackBase::momentum
const Vector & momentum() const
track momentum vector
Definition: TrackBase.h:148
w
const double w
Definition: UKUtility.cc:23
reco::SecondaryVertexTagInfo::flightDistance
Measurement1D flightDistance(unsigned int index, bool in2d=false) const
Definition: SecondaryVertexTagInfo.h:98
reco::Vertex::tracks_end
trackRef_iterator tracks_end() const
last iterator over tracks
Definition: Vertex.cc:44
reco::LeafCandidate::et
virtual double et() const
transverse energy
Definition: LeafCandidate.h:161
reco::TrackIPTagInfo::primaryVertex
const edm::Ref< VertexCollection > & primaryVertex() const
Definition: TrackIPTagInfo.h:107
reco::Vertex::refittedTrack
Track refittedTrack(const TrackBaseRef &track) const
range_for
#define range_for(i, x)
Definition: CombinedSVSoftLeptonComputer.cc:46
reco::Vertex::hasRefittedTracks
bool hasRefittedTracks() const
Checks whether refitted tracks are stored.
Definition: Vertex.h:134
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
PV3DBase::y
T y() const
Definition: PV3DBase.h:63
CombinedSVSoftLeptonComputer::sortCriterium
reco::TrackIPTagInfo::SortCriteria sortCriterium
Definition: CombinedSVSoftLeptonComputer.h:40
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
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:250
reco::SecondaryVertexTagInfo::flightDirection
const GlobalVector & flightDirection(unsigned int index) const
Definition: SecondaryVertexTagInfo.h:100
reco::SecondaryVertexTagInfo::secondaryVertex
const Vertex & secondaryVertex(unsigned int index) const
Definition: SecondaryVertexTagInfo.h:72
reco::Vertex::trackWeight
float trackWeight(const TrackBaseRef &r) const
returns the weight with which a Track has contributed to the vertex-fit.
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48
reco::SoftLeptonTagInfo::leptons
unsigned int leptons(void) const
Definition: SoftLeptonTagInfo.h:115
PV3DBase::z
T z() const
Definition: PV3DBase.h:64
j
int j
Definition: DBlmapReader.cc:9
etaRel
static double etaRel(const math::XYZVector &dir, const math::XYZVector &track)
Definition: CombinedSVSoftLeptonComputer.cc:136
CombinedSVSoftLeptonComputer::flipValue
double flipValue(double value, bool vertex) const
Definition: CombinedSVSoftLeptonComputer.cc:75
reco::JTATagInfo::jet
virtual edm::RefToBase< Jet > jet(void) const
returns a polymorphic reference to the tagged jet
Definition: JTATagInfo.h:20
deltaR
double deltaR(double eta1, double eta2, double phi1, double phi2)
Definition: TreeUtility.cc:17
reco::TrackIPTagInfo::sortedIndexes
std::vector< size_t > sortedIndexes(SortCriteria mode=IP3DSig) const
Definition: TrackIPTagInfo.cc:78
reco::SoftLeptonTagInfo::properties
const SoftLeptonProperties & properties(size_t i) const
Definition: SoftLeptonTagInfo.h:123
Measurement1D::significance
double significance() const
Definition: Measurement1D.h:32
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
pat::Jet
Analysis-level calorimeter jet class.
Definition: Jet.h:73
Measurement1D::value
double value() const
Definition: Measurement1D.h:28
data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:82
reco::TrackIPTagInfo::impactParameterData
const std::vector< TrackIPData > & impactParameterData() const
Definition: TrackIPTagInfo.h:68
reco::Vertex::trackRef_iterator
std::vector< TrackBaseRef >::const_iterator trackRef_iterator
The iteratator for the vector&lt;TrackRef&gt;
Definition: Vertex.h:37
edm::RefVector::size
size_type size() const
Size of the RefVector.
Definition: RefVector.h:89
dir
dbl *** dir
Definition: mlp_gen.cc:35
reco::Vertex::tracks_begin
trackRef_iterator tracks_begin() const
first iterator over tracks
Definition: Vertex.cc:39
CombinedSVSoftLeptonComputer::threshTrack
const reco::TrackIPTagInfo::TrackIPData & threshTrack(const reco::TrackIPTagInfo &trackIPTagInfo, const reco::TrackIPTagInfo::SortCriteria sort, const reco::Jet &jet, const GlobalPoint &pv) const
Definition: CombinedSVSoftLeptonComputer.cc:98
reco::TrackIPTagInfo::selectedTracks
const edm::RefVector< TrackCollection > & selectedTracks() const
Definition: TrackIPTagInfo.h:75
PV3DBase::x
T x() const
Definition: PV3DBase.h:62
CombinedSVSoftLeptonComputer::flipIterate
IterationRange flipIterate(int size, bool vertex) const
Definition: CombinedSVSoftLeptonComputer.cc:80
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:40
reco::TaggingVariableList::insert
void insert(const TaggingVariable &variable, bool delayed=false)
Definition: TaggingVariable.cc:221
const TrackIPTagInfo::TrackIPData & CombinedSVSoftLeptonComputer::threshTrack ( const reco::TrackIPTagInfo &  trackIPTagInfo,
const reco::TrackIPTagInfo::SortCriteria  sort,
const reco::Jet &  jet,
const GlobalPoint &  pv 
) const
private

Definition at line 98 of file CombinedSVSoftLeptonComputer.cc.

References charmCut, data, flipIterate(), i, customizeTrackingMonitorSeedNumber::idx, reco::TrackIPTagInfo::impactParameterData(), range_for, reco::TrackIPTagInfo::selectedTracks(), reco::TrackIPTagInfo::sortedIndexes(), trackNoDeltaRSelector, and testEve_cfg::tracks.

Referenced by operator()().

102 {
103  const edm::RefVector<TrackCollection> &tracks =
104  trackIPTagInfo.selectedTracks();
105  const std::vector<TrackIPTagInfo::TrackIPData> &ipData =
106  trackIPTagInfo.impactParameterData();
107  std::vector<std::size_t> indices = trackIPTagInfo.sortedIndexes(sort);
108 
109  IterationRange range = flipIterate(indices.size(), false);
110  TrackKinematics kin;
111  range_for(i, range) {
112  std::size_t idx = indices[i];
113  const TrackIPTagInfo::TrackIPData &data = ipData[idx];
114  const Track &track = *tracks[idx];
115 
116  if (!trackNoDeltaRSelector(track, data, jet, pv))
117  continue;
118 
119  kin.add(track);
120  if (kin.vectorSum().M() > charmCut)
121  return data;
122  }
123 
124  static const TrackIPTagInfo::TrackIPData dummy = {
125  GlobalPoint(),
126  GlobalPoint(),
127  Measurement1D(-1.0, 1.0),
128  Measurement1D(-1.0, 1.0),
129  Measurement1D(-1.0, 1.0),
130  Measurement1D(-1.0, 1.0),
131  0.
132  };
133  return dummy;
134 }
i
int i
Definition: DBlmapReader.cc:9
range_for
#define range_for(i, x)
Definition: CombinedSVSoftLeptonComputer.cc:46
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
reco::TrackIPTagInfo::sortedIndexes
std::vector< size_t > sortedIndexes(SortCriteria mode=IP3DSig) const
Definition: TrackIPTagInfo.cc:78
testEve_cfg.tracks
tuple tracks
Definition: testEve_cfg.py:39
customizeTrackingMonitorSeedNumber.idx
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
Definition: customizeTrackingMonitorSeedNumber.py:15
data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:82
reco::TrackIPTagInfo::impactParameterData
const std::vector< TrackIPData > & impactParameterData() const
Definition: TrackIPTagInfo.h:68
reco::TrackIPTagInfo::selectedTracks
const edm::RefVector< TrackCollection > & selectedTracks() const
Definition: TrackIPTagInfo.h:75
CombinedSVSoftLeptonComputer::flipIterate
IterationRange flipIterate(int size, bool vertex) const
Definition: CombinedSVSoftLeptonComputer.cc:80

Member Data Documentation

double CombinedSVSoftLeptonComputer::charmCut
private

Definition at line 39 of file CombinedSVSoftLeptonComputer.h.

Referenced by threshTrack().

double CombinedSVSoftLeptonComputer::minTrackWeight
private

Definition at line 46 of file CombinedSVSoftLeptonComputer.h.

Referenced by operator()().

unsigned int CombinedSVSoftLeptonComputer::pseudoMultiplicityMin
private

Definition at line 44 of file CombinedSVSoftLeptonComputer.h.

Referenced by operator()().

reco::V0Filter CombinedSVSoftLeptonComputer::pseudoVertexV0Filter
private

Definition at line 49 of file CombinedSVSoftLeptonComputer.h.

Referenced by operator()().

reco::TrackIPTagInfo::SortCriteria CombinedSVSoftLeptonComputer::sortCriterium
private

Definition at line 40 of file CombinedSVSoftLeptonComputer.h.

Referenced by operator()().

bool CombinedSVSoftLeptonComputer::trackFlip
private

Definition at line 37 of file CombinedSVSoftLeptonComputer.h.

Referenced by flipIterate(), and flipValue().

unsigned int CombinedSVSoftLeptonComputer::trackMultiplicityMin
private

Definition at line 45 of file CombinedSVSoftLeptonComputer.h.

Referenced by operator()().

reco::TrackSelector CombinedSVSoftLeptonComputer::trackNoDeltaRSelector
private

Definition at line 42 of file CombinedSVSoftLeptonComputer.h.

Referenced by threshTrack().

reco::V0Filter CombinedSVSoftLeptonComputer::trackPairV0Filter
private

Definition at line 50 of file CombinedSVSoftLeptonComputer.h.

Referenced by operator()().

reco::TrackSelector CombinedSVSoftLeptonComputer::trackPseudoSelector
private

Definition at line 43 of file CombinedSVSoftLeptonComputer.h.

Referenced by operator()().

reco::TrackSelector CombinedSVSoftLeptonComputer::trackSelector
private

Definition at line 41 of file CombinedSVSoftLeptonComputer.h.

Referenced by operator()().

bool CombinedSVSoftLeptonComputer::useTrackWeights
private

Definition at line 47 of file CombinedSVSoftLeptonComputer.h.

Referenced by operator()().

bool CombinedSVSoftLeptonComputer::vertexFlip
private

Definition at line 38 of file CombinedSVSoftLeptonComputer.h.

Referenced by flipIterate(), and flipValue().

bool CombinedSVSoftLeptonComputer::vertexMassCorrection
private

Definition at line 48 of file CombinedSVSoftLeptonComputer.h.

Referenced by operator()().

Generated for CMSSW Reference Manual by doxygen 1.8.5