#include <TrackIPTagInfo.h>

Inheritance diagram for reco::TrackIPTagInfo:

Classes
struct	TrackIPData
Public Types
enum	SortCriteria { IP3DSig = 0, Prob3D, IP2DSig, Prob2D, IP3DValue, IP2DValue }
Public Member Functions
const GlobalVector &	axis () const
virtual TrackIPTagInfo *	clone (void) const
	clone
const TrackRef &	ghostTrack () const
virtual bool	hasProbabilities () const
const std::vector< TrackIPData > &	impactParameterData () const
const edm::Ref < VertexCollection > &	primaryVertex () const
const std::vector< float > &	probabilities (int ip) const
const edm::RefVector < TrackCollection > &	selectedTracks () const
std::vector< size_t >	sortedIndexes (SortCriteria mode=IP3DSig) const
std::vector< size_t >	sortedIndexesWithCut (float cut, SortCriteria mode=IP3DSig) const
reco::TrackRefVector	sortedTracks (std::vector< size_t > indexes) const
virtual TaggingVariableList	taggingVariables (void) const
	returns a description of the extended informations in a TaggingVariableList
	TrackIPTagInfo ()
	TrackIPTagInfo (const std::vector< TrackIPData > &ipData, const std::vector< float > &prob2d, const std::vector< float > &prob3d, const edm::RefVector< TrackCollection > &selectedTracks, const JetTracksAssociationRef &jtaRef, const edm::Ref< VertexCollection > &pv, const GlobalVector &axis, const TrackRef &ghostTrack)
virtual	~TrackIPTagInfo ()
Private Attributes
GlobalVector	m_axis
std::vector< TrackIPData >	m_data
TrackRef	m_ghostTrack
std::vector< float >	m_prob2d
std::vector< float >	m_prob3d
edm::Ref< VertexCollection >	m_pv
edm::RefVector< TrackCollection >	m_selectedTracks

Detailed Description

Definition at line 15 of file TrackIPTagInfo.h.

Member Enumeration Documentation

enum reco::TrackIPTagInfo::SortCriteria

Enumerator:

IP3DSig
Prob3D
IP2DSig
Prob2D
IP3DValue
IP2DValue

Definition at line 72 of file TrackIPTagInfo.h.

                    { IP3DSig = 0, Prob3D, IP2DSig, Prob2D, 
                      IP3DValue, IP2DValue };

Constructor & Destructor Documentation

reco::TrackIPTagInfo::TrackIPTagInfo	(	const std::vector< TrackIPData > &	ipData,
		const std::vector< float > &	prob2d,
		const std::vector< float > &	prob3d,
		const edm::RefVector< TrackCollection > &	selectedTracks,
		const JetTracksAssociationRef &	jtaRef,
		const edm::Ref< VertexCollection > &	pv,
		const GlobalVector &	axis,
		const TrackRef &	ghostTrack
	)		`[inline]`

Definition at line 27 of file TrackIPTagInfo.h.

                                 :
      JTATagInfo(jtaRef), m_data(ipData),  m_prob2d(prob2d),
      m_prob3d(prob3d), m_selectedTracks(selectedTracks), m_pv(pv),
      m_axis(axis), m_ghostTrack(ghostTrack) {}

reco::TrackIPTagInfo::TrackIPTagInfo ( ) [inline]

Definition at line 40 of file TrackIPTagInfo.h.

Referenced by clone().

{}

virtual reco::TrackIPTagInfo::~TrackIPTagInfo ( ) [inline, virtual]

Definition at line 42 of file TrackIPTagInfo.h.

{}

Member Function Documentation

const GlobalVector& reco::TrackIPTagInfo::axis ( ) const [inline]

Definition at line 95 of file TrackIPTagInfo.h.

References m_axis.

{ return m_axis; }

virtual TrackIPTagInfo* reco::TrackIPTagInfo::clone ( void ) const [inline, virtual]

clone

Reimplemented from reco::JTATagInfo.

Definition at line 45 of file TrackIPTagInfo.h.

References TrackIPTagInfo().

  { return new TrackIPTagInfo(*this); }

const TrackRef& reco::TrackIPTagInfo::ghostTrack ( ) const [inline]

Definition at line 96 of file TrackIPTagInfo.h.

References m_ghostTrack.

{ return m_ghostTrack; }

virtual bool reco::TrackIPTagInfo::hasProbabilities ( ) const [inline, virtual]

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 56 of file TrackIPTagInfo.h.

References m_data, and m_prob3d.

Referenced by TrackIPTagPlotter::analyzeTag().

  { return m_data.size() == m_prob3d.size(); }

const std::vector<TrackIPData>& reco::TrackIPTagInfo::impactParameterData ( ) const [inline]

Vectors of TrackIPData orderd as the selectedTracks()

Definition at line 62 of file TrackIPTagInfo.h.

References m_data.

Referenced by HLTMonBTagIPSource::analyze(), TrackIPTagPlotter::analyzeTag(), JetBProbabilityComputer::discriminator(), JetProbabilityComputer::discriminator(), CombinedSVComputer::operator()(), GhostTrackComputer::operator()(), TrackCountingComputer::orderedSignificances(), GhostTrackComputer::threshTrack(), and CombinedSVComputer::threshTrack().

  { return m_data; }

const edm::Ref<VertexCollection>& reco::TrackIPTagInfo::primaryVertex ( ) const [inline]

Definition at line 93 of file TrackIPTagInfo.h.

References m_pv.

Referenced by TrackIPTagPlotter::analyzeTag(), JetBProbabilityComputer::discriminator(), JetProbabilityComputer::discriminator(), CombinedSVComputer::operator()(), GhostTrackComputer::operator()(), and TrackCountingComputer::orderedSignificances().

{ return m_pv; }

const std::vector<float>& reco::TrackIPTagInfo::probabilities ( int ip ) const [inline]

Definition at line 70 of file TrackIPTagInfo.h.

References m_prob2d, and m_prob3d.

Referenced by TrackIPTagPlotter::analyzeTag(), JetBProbabilityComputer::discriminator(), and JetProbabilityComputer::discriminator().

{return (ip==0)?m_prob3d:m_prob2d; }

const edm::RefVector<TrackCollection>& reco::TrackIPTagInfo::selectedTracks ( ) 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 69 of file TrackIPTagInfo.h.

References m_selectedTracks.

Referenced by HLTMonBTagIPSource::analyze(), TrackIPTagPlotter::analyzeTag(), JetBProbabilityComputer::discriminator(), JetProbabilityComputer::discriminator(), CombinedSVComputer::operator()(), GhostTrackComputer::operator()(), TrackCountingComputer::orderedSignificances(), GhostTrackComputer::threshTrack(), and CombinedSVComputer::threshTrack().

{ return m_selectedTracks; }

std::vector< size_t > TrackIPTagInfo::sortedIndexes ( SortCriteria mode = IP3DSig ) const

Return the list of track index sorted by mode

Definition at line 78 of file TrackIPTagInfo.cc.

References align_tpl::cut.

Referenced by HLTMonBTagIPSource::analyze(), TrackIPTagPlotter::analyzeTag(), CombinedSVComputer::operator()(), GhostTrackComputer::operator()(), GhostTrackComputer::threshTrack(), and CombinedSVComputer::threshTrack().

{
 float cut=-1e99;
 if((mode == Prob3D || mode == Prob2D)) cut=1e99;
 return sortedIndexesWithCut(cut,mode);
}

std::vector< size_t > TrackIPTagInfo::sortedIndexesWithCut	(	float	cut,
		SortCriteria	mode = `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 85 of file TrackIPTagInfo.cc.

References i, and query::result.

{
 multimap<float,size_t> sortedIdx;
 size_t nSelectedTracks = m_selectedTracks.size();
 std::vector<size_t> result;
 
//check if probabilities are available
 if((mode == Prob3D || mode == Prob2D) && ! hasProbabilities()) 
  {
   return result;
  }

 for(size_t i=0;i<nSelectedTracks;i++) 
  {
     float sortingKey;
     switch(mode)
     {
      case IP3DSig:
           sortingKey=m_data[i].ip3d.significance();
           break;
      case IP2DSig:
           sortingKey=m_data[i].ip2d.significance();
           break;
      case IP3DValue:
           sortingKey=m_data[i].ip3d.value();
           break;
      case IP2DValue:
           sortingKey=m_data[i].ip2d.value();
           break;
      case Prob3D:
           sortingKey=m_prob3d[i];
           break;
      case Prob2D:
           sortingKey=m_prob2d[i];
           break;

      default:
       sortingKey=i;
     }   
     sortedIdx.insert(std::pair<float,size_t>(sortingKey,i));
  }

//Descending: 
if(mode == IP3DSig || mode == IP2DSig ||mode ==  IP3DValue || mode == IP2DValue)
 { 
   for(std::multimap<float,size_t>::reverse_iterator it = sortedIdx.rbegin(); it!=sortedIdx.rend(); it++)
    if(it->first >= cut) result.push_back(it->second);
 } else
//Ascending:
 {
  for(std::multimap<float,size_t>::iterator it = sortedIdx.begin(); it!=sortedIdx.end(); it++)
    if(it->first <= cut) result.push_back(it->second);
 }
 return result;
}

TrackRefVector TrackIPTagInfo::sortedTracks ( std::vector< size_t > indexes ) const

Definition at line 71 of file TrackIPTagInfo.cc.

References i, and edm::RefVector< C, T, F >::push_back().

Referenced by TrackIPTagPlotter::analyzeTag().

{
 TrackRefVector tr;
 for(size_t i =0 ; i < indexes.size(); i++) tr.push_back(m_selectedTracks[indexes[i]]);
 return tr;
}

TaggingVariableList TrackIPTagInfo::taggingVariables ( void ) const [virtual]

returns a description of the extended informations in a TaggingVariableList

Reimplemented from reco::BaseTagInfo.

Definition at line 24 of file TrackIPTagInfo.cc.

References runTheMatrix::data, etaRel(), reco::TaggingVariableList::finalize(), reco::TaggingVariableList::insert(), metsig::jet, mathSSE::sqrt(), 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, x, detailsBasic3DVector::y, and z.

                                                               {
  TaggingVariableList vars;

  math::XYZVector jetDir = jet()->momentum().Unit();
  bool havePv = primaryVertex().isNonnull();
  GlobalPoint pv;
  if (havePv)
    pv = GlobalPoint(primaryVertex()->x(),
                     primaryVertex()->y(),
                     primaryVertex()->z());

  std::vector<size_t> indexes = sortedIndexes(); // use default criterium
  for(std::vector<size_t>::const_iterator it = indexes.begin();
      it != indexes.end(); ++it)
   {
     using namespace ROOT::Math;
     TrackRef track = m_selectedTracks[*it];
     const TrackIPData *data = &m_data[*it];
     math::XYZVector trackMom = track->momentum();
     double trackMag = std::sqrt(trackMom.Mag2());

     vars.insert(btau::trackMomentum, trackMag, true);
     vars.insert(btau::trackEta, trackMom.Eta(), true);
     vars.insert(btau::trackEtaRel, etaRel(jetDir, trackMom), true);
     vars.insert(btau::trackPtRel, VectorUtil::Perp(trackMom, jetDir), true);
     vars.insert(btau::trackPPar, jetDir.Dot(trackMom), true);
     vars.insert(btau::trackDeltaR, VectorUtil::DeltaR(trackMom, jetDir), true);
     vars.insert(btau::trackPtRatio, VectorUtil::Perp(trackMom, jetDir) / trackMag, true);
     vars.insert(btau::trackPParRatio, jetDir.Dot(trackMom) / trackMag, true);
     vars.insert(btau::trackSip3dVal, data->ip3d.value(), true);
     vars.insert(btau::trackSip3dSig, data->ip3d.significance(), true);
     vars.insert(btau::trackSip2dVal, data->ip2d.value(), true);
     vars.insert(btau::trackSip2dSig, data->ip2d.significance(), true);
     vars.insert(btau::trackDecayLenVal, havePv ? (data->closestToJetAxis - pv).mag() : -1.0, true);
     vars.insert(btau::trackJetDistVal, data->distanceToJetAxis.value(), true);
     vars.insert(btau::trackJetDistSig, data->distanceToJetAxis.significance(), true);
     vars.insert(btau::trackGhostTrackDistVal, data->distanceToGhostTrack.value(), true);
     vars.insert(btau::trackGhostTrackDistSig, data->distanceToGhostTrack.significance(), true);
     vars.insert(btau::trackGhostTrackWeight, data->ghostTrackWeight, true);
     vars.insert(btau::trackChi2, track->normalizedChi2(), true);
     vars.insert(btau::trackNTotalHits, track->hitPattern().numberOfValidHits(), true);
     vars.insert(btau::trackNPixelHits, track->hitPattern().numberOfValidPixelHits(), true);
   } 
  vars.finalize();
  return vars;
}