CMS 3D CMS Logo

List of all members | Public Types | Public Member Functions | Static Public Member Functions | Private Attributes
reco::IPTagInfo< Container, Base > Class Template Reference

#include <IPTagInfo.h>

Inheritance diagram for reco::IPTagInfo< Container, Base >:

Public Types

typedef Base base_class
 
typedef Container input_container
 

Public Member Functions

const GlobalVectoraxis () const
 
IPTagInfoclone (void) const override
 clone More...
 
const TrackRefghostTrack () const
 
virtual bool hasProbabilities () const
 
const std::vector< btag::TrackIPData > & impactParameterData () const
 
 IPTagInfo (const std::vector< btag::TrackIPData > &ipData, const std::vector< float > &prob2d, const std::vector< float > &prob3d, const Container &selected, const Base &base, const edm::Ref< VertexCollection > &pv, const GlobalVector &axis, const TrackRef &ghostTrack)
 
 IPTagInfo ()
 
const edm::Ref< VertexCollection > & primaryVertex () const
 
const std::vector< float > & probabilities (int ip) const
 
const Container & selected () const
 
const TrackselectedTrack (size_t i) const
 
const Container & selectedTracks () const
 
Container sorted (const std::vector< size_t > &indexes) const
 
std::vector< size_t > sortedIndexes (btag::SortCriteria mode=reco::btag::IP3DSig) const
 
std::vector< size_t > sortedIndexesWithCut (float cut, btag::SortCriteria mode=reco::btag::IP3DSig) const
 
Container sortedTracks (const std::vector< size_t > &indexes) const
 
TaggingVariableList taggingVariables (void) const override
 
std::vector< bool > variableJTA (const btag::variableJTAParameters &params) const
 
 ~IPTagInfo () override
 

Static Public Member Functions

static short Class_Version ()
 
static bool passVariableJTA (const btag::variableJTAParameters &params, double jetpt, double trackpt, double jettrackdr)
 

Private Attributes

GlobalVector m_axis
 
std::vector< btag::TrackIPDatam_data
 
TrackRef m_ghostTrack
 
std::vector< float > m_prob2d
 
std::vector< float > m_prob3d
 
edm::Ref< VertexCollectionm_pv
 
Container m_selected
 

Detailed Description

template<class Container, class Base>
class reco::IPTagInfo< Container, Base >

Definition at line 51 of file IPTagInfo.h.

Member Typedef Documentation

template<class Container, class Base>
typedef Base reco::IPTagInfo< Container, Base >::base_class

Definition at line 54 of file IPTagInfo.h.

template<class Container, class Base>
typedef Container reco::IPTagInfo< Container, Base >::input_container

Definition at line 53 of file IPTagInfo.h.

Constructor & Destructor Documentation

template<class Container, class Base>
reco::IPTagInfo< Container, Base >::IPTagInfo ( const std::vector< btag::TrackIPData > &  ipData,
const std::vector< float > &  prob2d,
const std::vector< float > &  prob3d,
const Container &  selected,
const Base &  base,
const edm::Ref< VertexCollection > &  pv,
const GlobalVector axis,
const TrackRef ghostTrack 
)
inline

Definition at line 56 of file IPTagInfo.h.

64  :
65  Base(base), m_data(ipData), m_prob2d(prob2d),
66  m_prob3d(prob3d), m_selected(selected), m_pv(pv),
67  m_axis(axis), m_ghostTrack(ghostTrack) {}
Container m_selected
Definition: IPTagInfo.h:147
std::vector< float > m_prob3d
Definition: IPTagInfo.h:146
def Base(process)
edm::Ref< VertexCollection > m_pv
Definition: IPTagInfo.h:148
TrackRef m_ghostTrack
Definition: IPTagInfo.h:150
std::vector< float > m_prob2d
Definition: IPTagInfo.h:145
const Container & selected() const
Definition: IPTagInfo.h:98
base
Make Sure CMSSW is Setup ##.
std::vector< btag::TrackIPData > m_data
Definition: IPTagInfo.h:144
const TrackRef & ghostTrack() const
Definition: IPTagInfo.h:136
GlobalVector m_axis
Definition: IPTagInfo.h:149
template<class Container, class Base>
reco::IPTagInfo< Container, Base >::IPTagInfo ( )
inline

Definition at line 69 of file IPTagInfo.h.

69 {}
template<class Container, class Base>
reco::IPTagInfo< Container, Base >::~IPTagInfo ( )
inlineoverride

Definition at line 71 of file IPTagInfo.h.

71 {}

Member Function Documentation

template<class Container, class Base>
const GlobalVector& reco::IPTagInfo< Container, Base >::axis ( ) const
inline

Definition at line 135 of file IPTagInfo.h.

135 { return m_axis; }
GlobalVector m_axis
Definition: IPTagInfo.h:149
template<class Container, class Base>
static short reco::IPTagInfo< Container, Base >::Class_Version ( )
inlinestatic

Definition at line 141 of file IPTagInfo.h.

143 :
144  std::vector<btag::TrackIPData> m_data;
std::vector< btag::TrackIPData > m_data
Definition: IPTagInfo.h:144
template<class Container, class Base>
IPTagInfo* reco::IPTagInfo< Container, Base >::clone ( void  ) const
inlineoverride

clone

Definition at line 74 of file IPTagInfo.h.

75  { return new IPTagInfo(*this); }
template<class Container, class Base>
const TrackRef& reco::IPTagInfo< Container, Base >::ghostTrack ( ) const
inline

Definition at line 136 of file IPTagInfo.h.

136 { return m_ghostTrack; }
TrackRef m_ghostTrack
Definition: IPTagInfo.h:150
template<class Container, class Base>
virtual bool reco::IPTagInfo< Container, Base >::hasProbabilities ( ) const
inlinevirtual

Check if probability information is globally available impact parameters in the collection

Even if true for some tracks it is possible that a -1 probability is returned if some problem occured

Definition at line 85 of file IPTagInfo.h.

Referenced by IPTagPlotter< Container, Base >::analyzeTag().

86  { return m_data.size() == m_prob3d.size(); }
std::vector< float > m_prob3d
Definition: IPTagInfo.h:146
std::vector< btag::TrackIPData > m_data
Definition: IPTagInfo.h:144
template<class Container, class Base>
const std::vector<btag::TrackIPData>& reco::IPTagInfo< Container, Base >::impactParameterData ( ) const
inline
template<class Container , class Base >
bool reco::IPTagInfo< Container, Base >::passVariableJTA ( const btag::variableJTAParameters params,
double  jetpt,
double  trackpt,
double  jettrackdr 
)
static

Definition at line 303 of file IPTagInfo.h.

References reco::btag::variableJTAParameters::a_dR, reco::btag::variableJTAParameters::a_pT, reco::btag::variableJTAParameters::b_dR, reco::btag::variableJTAParameters::b_pT, reco::btag::variableJTAParameters::max_pT, reco::btag::variableJTAParameters::max_pT_dRcut, reco::btag::variableJTAParameters::max_pT_trackPTcut, reco::btag::variableJTAParameters::min_pT, and reco::btag::variableJTAParameters::min_pT_dRcut.

Referenced by reco::TrackSelector::operator()().

303  {
304 
305  bool pass = false;
306 
307  // intermediate pt range (between min_pT and max_pT), apply variable JTA !
308  if ( jetpT > params.min_pT && jetpT < params.max_pT ) {
309  double deltaRfunction_highpt = -jetpT * params.a_dR + params.b_dR;
310  double ptfunction_highpt = jetpT * params.a_pT + params.b_pT;
311 
312  if (jettrackdR < deltaRfunction_highpt
313  &&
314  trackpT > ptfunction_highpt)
315  pass = true;
316 
317  // cout << "IPTagInfo: passVariableJTA: dR and TrackpT " << jettrackdR << " " << trackpT << endl;
318 
319  //high pt range, apply fixed default cuts
320  }else if (jetpT > params.max_pT ) {
321  if (jettrackdR < params.max_pT_dRcut
322  &&
323  trackpT > params.max_pT_trackPTcut)
324  pass = true;
325 
326  // low pt range, apply fixed default cuts
327  }else {
328  if (jettrackdR < params.min_pT_dRcut)
329  pass = true;
330  }
331 
332  return pass;
333 }
template<class Container, class Base>
const edm::Ref<VertexCollection>& reco::IPTagInfo< Container, Base >::primaryVertex ( ) const
inline
template<class Container, class Base>
const std::vector<float>& reco::IPTagInfo< Container, Base >::probabilities ( int  ip) const
inline
template<class Container, class Base>
const Container& reco::IPTagInfo< Container, Base >::selected ( ) const
inline

Return the vector of tracks for which the IP information is available Quality cuts are applied to reject fake tracks

Definition at line 98 of file IPTagInfo.h.

98 { return m_selected; }
Container m_selected
Definition: IPTagInfo.h:147
template<class Container, class Base>
const Track* reco::IPTagInfo< Container, Base >::selectedTrack ( size_t  i) const
inline

Definition at line 138 of file IPTagInfo.h.

References reco::btag::toTrack().

138 {return reco::btag::toTrack(m_selected[i]);}
Container m_selected
Definition: IPTagInfo.h:147
const reco::Track * toTrack(const reco::TrackBaseRef &t)
Definition: IPTagInfo.h:24
template<class Container, class Base>
const Container& reco::IPTagInfo< Container, Base >::selectedTracks ( ) const
inline
template<class Container , class Base >
Container reco::IPTagInfo< Container, Base >::sorted ( const std::vector< size_t > &  indexes) const

Definition at line 205 of file IPTagInfo.h.

References mps_fire::i.

206 {
207  Container tr;
208  for(size_t i =0 ; i < indexes.size(); i++) tr.push_back(m_selected[indexes[i]]);
209  return tr;
210 }
Container m_selected
Definition: IPTagInfo.h:147
edm::AssociationVector< reco::JetRefBaseProd, Values > Container
template<class Container , class Base >
std::vector< size_t > reco::IPTagInfo< Container, Base >::sortedIndexes ( btag::SortCriteria  mode = reco::btag::IP3DSig) const

Return the list of track index sorted by mode

Definition at line 238 of file IPTagInfo.h.

References reco::btag::Prob2D, and reco::btag::Prob3D.

Referenced by IPTagPlotter< Container, Base >::analyzeTag(), CombinedSVComputer::flipIterate(), GhostTrackComputer::GhostTrackComputer(), GhostTrackComputer::operator()(), and BoostedDoubleSVProducer::produce().

239 {
240  using namespace reco::btag;
241  float cut=-1e99;
242  if((mode == Prob3D || mode == Prob2D)) cut=1e99;
243  return sortedIndexesWithCut(cut,mode);
244 }
std::vector< size_t > sortedIndexesWithCut(float cut, btag::SortCriteria mode=reco::btag::IP3DSig) const
Definition: IPTagInfo.h:246
template<class Container , class Base >
std::vector< size_t > reco::IPTagInfo< Container, Base >::sortedIndexesWithCut ( float  cut,
btag::SortCriteria  mode = reco::btag::IP3DSig 
) const

Return the list of track index sorted by mode A cut can is specified to select only tracks with IP value or significance > cut or probability < cut (according to the specified mode)

Definition at line 246 of file IPTagInfo.h.

References mps_fire::i, reco::btag::IP2DSig, reco::btag::IP2DValue, reco::btag::IP3DSig, reco::btag::IP3DValue, reco::btag::Prob2D, reco::btag::Prob3D, and mps_fire::result.

247 {
248  std::multimap<float,size_t> sortedIdx;
249  size_t nSelectedTracks = m_selected.size();
250  std::vector<size_t> result;
251  using namespace reco::btag;
252 
253 //check if probabilities are available
254  if((mode == Prob3D || mode == Prob2D) && ! hasProbabilities())
255  {
256  return result;
257  }
258 
259  for(size_t i=0;i<nSelectedTracks;i++)
260  {
261  float sortingKey;
262  switch(mode)
263  {
264  case IP3DSig:
265  sortingKey=m_data[i].ip3d.significance();
266  break;
267  case IP2DSig:
268  sortingKey=m_data[i].ip2d.significance();
269  break;
270  case IP3DValue:
271  sortingKey=m_data[i].ip3d.value();
272  break;
273  case IP2DValue:
274  sortingKey=m_data[i].ip2d.value();
275  break;
276  case Prob3D:
277  sortingKey=m_prob3d[i];
278  break;
279  case Prob2D:
280  sortingKey=m_prob2d[i];
281  break;
282 
283  default:
284  sortingKey=i;
285  }
286  sortedIdx.insert(std::pair<float,size_t>(sortingKey,i));
287  }
288 
289 //Descending:
290 if(mode == IP3DSig || mode == IP2DSig ||mode == IP3DValue || mode == IP2DValue)
291  {
292  for(std::multimap<float,size_t>::reverse_iterator it = sortedIdx.rbegin(); it!=sortedIdx.rend(); it++)
293  if(it->first >= cut) result.push_back(it->second);
294  } else
295 //Ascending:
296  {
297  for(std::multimap<float,size_t>::iterator it = sortedIdx.begin(); it!=sortedIdx.end(); it++)
298  if(it->first <= cut) result.push_back(it->second);
299  }
300  return result;
301 }
Container m_selected
Definition: IPTagInfo.h:147
std::vector< float > m_prob3d
Definition: IPTagInfo.h:146
std::vector< float > m_prob2d
Definition: IPTagInfo.h:145
std::vector< btag::TrackIPData > m_data
Definition: IPTagInfo.h:144
virtual bool hasProbabilities() const
Definition: IPTagInfo.h:85
template<class Container, class Base>
Container reco::IPTagInfo< Container, Base >::sortedTracks ( const std::vector< size_t > &  indexes) const
inline

Definition at line 129 of file IPTagInfo.h.

Referenced by IPTagPlotter< Container, Base >::analyzeTag().

129 {return sorted(indexes);}
Container sorted(const std::vector< size_t > &indexes) const
Definition: IPTagInfo.h:205
template<class Container , class Base >
TaggingVariableList reco::IPTagInfo< Container, Base >::taggingVariables ( void  ) const
override

Definition at line 158 of file IPTagInfo.h.

References reco::btag::TrackIPData::closestToJetAxis, data, HiRegitMuonDetachedTripletStep_cff::DeltaR, reco::btag::TrackIPData::distanceToGhostTrack, reco::btag::TrackIPData::distanceToJetAxis, reco::btau::etaRel(), reco::TaggingVariableList::finalize(), reco::btag::TrackIPData::ghostTrackWeight, reco::TrackBase::hitPattern(), reco::TaggingVariableList::insert(), reco::btag::TrackIPData::ip2d, reco::btag::TrackIPData::ip3d, metsig::jet, reco::TrackBase::momentum(), reco::TrackBase::normalizedChi2(), reco::HitPattern::numberOfValidHits(), reco::HitPattern::numberOfValidPixelHits(), impactParameterTagInfos_cfi::primaryVertex, MetAnalyzer::pv(), Measurement1D::significance(), mathSSE::sqrt(), HiIsolationCommonParameters_cff::track, reco::btau::trackChi2, reco::btau::trackDecayLenVal, reco::btau::trackDeltaR, reco::btau::trackEta, reco::btau::trackEtaRel, reco::btau::trackGhostTrackDistSig, reco::btau::trackGhostTrackDistVal, reco::btau::trackGhostTrackWeight, reco::btau::trackJetDistSig, reco::btau::trackJetDistVal, reco::btau::trackMomentum, reco::btau::trackNPixelHits, reco::btau::trackNTotalHits, reco::btau::trackPPar, reco::btau::trackPParRatio, reco::btau::trackPtRatio, reco::btau::trackPtRel, reco::btau::trackSip2dSig, reco::btau::trackSip2dVal, reco::btau::trackSip3dSig, reco::btau::trackSip3dVal, and Measurement1D::value().

158  {
159  TaggingVariableList vars;
160 
161  math::XYZVector jetDir = Base::jet()->momentum().Unit();
162  bool havePv = primaryVertex().isNonnull();
163  GlobalPoint pv;
164  if (havePv)
165  pv = GlobalPoint(primaryVertex()->x(),
166  primaryVertex()->y(),
167  primaryVertex()->z());
168 
169  std::vector<size_t> indexes = sortedIndexes(); // use default criterium
170  for(std::vector<size_t>::const_iterator it = indexes.begin();
171  it != indexes.end(); ++it)
172  {
173  using namespace ROOT::Math;
174  const Track * track = selectedTrack(*it);
175  const btag::TrackIPData *data = &m_data[*it];
176  const math::XYZVector& trackMom = track->momentum();
177  double trackMag = std::sqrt(trackMom.Mag2());
178 
179  vars.insert(btau::trackMomentum, trackMag, true);
180  vars.insert(btau::trackEta, trackMom.Eta(), true);
181  vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir, trackMom), true);
182  vars.insert(btau::trackPtRel, VectorUtil::Perp(trackMom, jetDir), true);
183  vars.insert(btau::trackPPar, jetDir.Dot(trackMom), true);
184  vars.insert(btau::trackDeltaR, VectorUtil::DeltaR(trackMom, jetDir), true);
185  vars.insert(btau::trackPtRatio, VectorUtil::Perp(trackMom, jetDir) / trackMag, true);
186  vars.insert(btau::trackPParRatio, jetDir.Dot(trackMom) / trackMag, true);
187  vars.insert(btau::trackSip3dVal, data->ip3d.value(), true);
188  vars.insert(btau::trackSip3dSig, data->ip3d.significance(), true);
189  vars.insert(btau::trackSip2dVal, data->ip2d.value(), true);
190  vars.insert(btau::trackSip2dSig, data->ip2d.significance(), true);
191  vars.insert(btau::trackDecayLenVal, havePv ? (data->closestToJetAxis - pv).mag() : -1.0, true);
192  vars.insert(btau::trackJetDistVal, data->distanceToJetAxis.value(), true);
193  vars.insert(btau::trackJetDistSig, data->distanceToJetAxis.significance(), true);
194  vars.insert(btau::trackGhostTrackDistVal, data->distanceToGhostTrack.value(), true);
195  vars.insert(btau::trackGhostTrackDistSig, data->distanceToGhostTrack.significance(), true);
196  vars.insert(btau::trackGhostTrackWeight, data->ghostTrackWeight, true);
197  vars.insert(btau::trackChi2, track->normalizedChi2(), true);
198  vars.insert(btau::trackNTotalHits, track->hitPattern().numberOfValidHits(), true);
199  vars.insert(btau::trackNPixelHits, track->hitPattern().numberOfValidPixelHits(), true);
200  }
201  vars.finalize();
202  return vars;
203 }
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:251
double etaRel(const math::XYZVector &dir, const math::XYZVector &track)
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
const edm::Ref< VertexCollection > & primaryVertex() const
Definition: IPTagInfo.h:133
T sqrt(T t)
Definition: SSEVec.h:18
def pv(vc)
Definition: MetAnalyzer.py:7
std::vector< size_t > sortedIndexes(btag::SortCriteria mode=reco::btag::IP3DSig) const
Definition: IPTagInfo.h:238
const Track * selectedTrack(size_t i) const
Definition: IPTagInfo.h:138
XYZVectorD XYZVector
spatial vector with cartesian internal representation
Definition: Vector3D.h:30
std::vector< btag::TrackIPData > m_data
Definition: IPTagInfo.h:144
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:82
vars
Definition: DeepTauId.cc:77
template<class Container , class Base >
std::vector< bool > reco::IPTagInfo< Container, Base >::variableJTA ( const btag::variableJTAParameters params) const

variable jet-to track association: returns vector of bool, indicating for each track whether it passed the variable JTA.

Definition at line 212 of file IPTagInfo.h.

References HiRegitMuonDetachedTripletStep_cff::DeltaR, mps_fire::i, metsig::jet, reco::TrackBase::momentum(), reco::TrackBase::pt(), mps_fire::result, and HiIsolationCommonParameters_cff::track.

Referenced by TemplatedJetProbabilityComputer< Container, Base >::discriminator(), TemplatedJetBProbabilityComputer< Container, Base >::discriminator(), and TemplatedTrackCountingComputer< Container, Base >::orderedSignificances().

212  {
213 
214  std::vector<bool> result;
215 
216  //Jet parameters
217  double jetpT = Base::jet()->pt();
218  math::XYZVector jetDir = Base::jet()->momentum().Unit();
219 
220  for(size_t i = 0 ; i< m_selected.size(); i++) {
221 
222  //Track parameters
223  const Track * track = selectedTrack(i);
224  double trackpT = track->pt();
225  const math::XYZVector& trackMom = track->momentum();
226 
227  // do the math in passVariableJTA
228  result.push_back(passVariableJTA( params, jetpT, trackpT, ROOT::Math::VectorUtil::DeltaR(trackMom, jetDir)));
229 
230  }
231 
232  return result;
233 }
Container m_selected
Definition: IPTagInfo.h:147
static bool passVariableJTA(const btag::variableJTAParameters &params, double jetpt, double trackpt, double jettrackdr)
Definition: IPTagInfo.h:303
const Track * selectedTrack(size_t i) const
Definition: IPTagInfo.h:138
XYZVectorD XYZVector
spatial vector with cartesian internal representation
Definition: Vector3D.h:30

Member Data Documentation

template<class Container, class Base>
GlobalVector reco::IPTagInfo< Container, Base >::m_axis
private

Definition at line 149 of file IPTagInfo.h.

template<class Container, class Base>
std::vector<btag::TrackIPData> reco::IPTagInfo< Container, Base >::m_data
private

Definition at line 144 of file IPTagInfo.h.

template<class Container, class Base>
TrackRef reco::IPTagInfo< Container, Base >::m_ghostTrack
private

Definition at line 150 of file IPTagInfo.h.

template<class Container, class Base>
std::vector<float> reco::IPTagInfo< Container, Base >::m_prob2d
private

Definition at line 145 of file IPTagInfo.h.

template<class Container, class Base>
std::vector<float> reco::IPTagInfo< Container, Base >::m_prob3d
private

Definition at line 146 of file IPTagInfo.h.

template<class Container, class Base>
edm::Ref<VertexCollection> reco::IPTagInfo< Container, Base >::m_pv
private

Definition at line 148 of file IPTagInfo.h.

template<class Container, class Base>
Container reco::IPTagInfo< Container, Base >::m_selected
private

Definition at line 147 of file IPTagInfo.h.