#include <TemplatedTrackCountingComputer.h>

Inheritance diagram for TemplatedTrackCountingComputer< Container, Base >:

Public Types
typedef reco::IPTagInfo< Container, Base >	TagInfo

using	Tokens = void

Public Member Functions
float	discriminator (const TagInfoHelper &ti) const override

	TemplatedTrackCountingComputer (const edm::ParameterSet &parameters)

Public Member Functions inherited from JetTagComputer
const std::vector< std::string > &	getInputLabels () const

virtual void	initialize (const JetTagComputerRecord &)

	JetTagComputer ()

	JetTagComputer (const edm::ParameterSet &configuration)

float	operator() (const reco::BaseTagInfo &info) const

float	operator() (const TagInfoHelper &helper) const

void	setupDone ()

virtual	~JetTagComputer ()

Protected Member Functions
std::multiset< float >	orderedSignificances (const TagInfo &tkip) const

Protected Member Functions inherited from JetTagComputer
virtual float	discriminator (const reco::BaseTagInfo &) const

void	uses (unsigned int id, const std::string &label)

void	uses (const std::string &label)

Protected Attributes
double	m_cutMaxDecayLen

double	m_cutMaxDistToAxis

double	m_deltaR

int	m_ipType

double	m_minIP

int	m_nthTrack

reco::TrackBase::TrackQuality	m_trackQuality

bool	m_useAllQualities

bool	m_useSignedIPSig

bool	useVariableJTA_

reco::btag::variableJTAParameters	varJTApars

Detailed Description

template<class Container, class Base>
class TemplatedTrackCountingComputer< Container, Base >

Definition at line 12 of file TemplatedTrackCountingComputer.h.

Member Typedef Documentation

◆ TagInfo

template<class Container, class Base>

typedef reco::IPTagInfo<Container, Base> TemplatedTrackCountingComputer< Container, Base >::TagInfo

Definition at line 16 of file TemplatedTrackCountingComputer.h.

◆ Tokens

template<class Container, class Base>

using TemplatedTrackCountingComputer< Container, Base >::Tokens = void

Definition at line 14 of file TemplatedTrackCountingComputer.h.

Constructor & Destructor Documentation

◆ TemplatedTrackCountingComputer()

template<class Container, class Base>

TemplatedTrackCountingComputer< Container, Base >::TemplatedTrackCountingComputer ( const edm::ParameterSet & parameters )

inline

Definition at line 18 of file TemplatedTrackCountingComputer.h.

                                                                     {
     m_minIP = parameters.existsAs<double>("minimumImpactParameter")
                   ? parameters.getParameter<double>("minimumImpactParameter")
                   : -1;
     m_useSignedIPSig = parameters.existsAs<bool>("useSignedImpactParameterSig")
                            ? parameters.getParameter<bool>("useSignedImpactParameterSig")
                            : true;
     m_nthTrack = parameters.getParameter<int>("nthTrack");
     m_ipType = parameters.getParameter<int>("impactParameterType");
     m_deltaR = parameters.getParameter<double>("deltaR");
     m_cutMaxDecayLen = parameters.getParameter<double>("maximumDecayLength");          //used
     m_cutMaxDistToAxis = parameters.getParameter<double>("maximumDistanceToJetAxis");  //used
     //
     // access track quality class; "any" takes everything
     //
     std::string trackQualityType = parameters.getParameter<std::string>("trackQualityClass");  //used
     m_trackQuality = reco::TrackBase::qualityByName(trackQualityType);
     m_useAllQualities = false;
     if (trackQualityType == "any" || trackQualityType == "Any" || trackQualityType == "ANY")
       m_useAllQualities = true;
 
     uses("ipTagInfos");
 
     useVariableJTA_ =
         parameters.existsAs<bool>("useVariableJTA") ? parameters.getParameter<bool>("useVariableJTA") : false;
     if (useVariableJTA_) {
       varJTApars = {parameters.getParameter<double>("a_dR"),
                     parameters.getParameter<double>("b_dR"),
                     parameters.getParameter<double>("a_pT"),
                     parameters.getParameter<double>("b_pT"),
                     parameters.getParameter<double>("min_pT"),
                     parameters.getParameter<double>("max_pT"),
                     parameters.getParameter<double>("min_pT_dRcut"),
                     parameters.getParameter<double>("max_pT_dRcut"),
                     parameters.getParameter<double>("max_pT_trackPTcut")};
     }
   }

Member Function Documentation

◆ discriminator()

template<class Container, class Base>

float TemplatedTrackCountingComputer< Container, Base >::discriminator ( const TagInfoHelper & ti ) const

inlineoverridevirtual

Reimplemented from JetTagComputer.

Definition at line 56 of file TemplatedTrackCountingComputer.h.

References JetTagComputer::TagInfoHelper::get(), mps_fire::i, TemplatedTrackCountingComputer< Container, Base >::m_nthTrack, and TemplatedTrackCountingComputer< Container, Base >::orderedSignificances().

                                                               {
     const TagInfo& tkip = ti.get<TagInfo>();
     std::multiset<float> significances = orderedSignificances(tkip);
     std::multiset<float>::reverse_iterator nth = significances.rbegin();
     for (int i = 0; i < m_nthTrack - 1 && nth != significances.rend(); i++)
       nth++;
     if (nth != significances.rend())
       return *nth;
     else
       return -100.;
   }

◆ orderedSignificances()

template<class Container, class Base>

std::multiset<float> TemplatedTrackCountingComputer< Container, Base >::orderedSignificances ( const TagInfo & tkip ) const

inlineprotected

Definition at line 69 of file TemplatedTrackCountingComputer.h.

Referenced by TemplatedNegativeTrackCountingComputer< Container, Base >::discriminator(), and TemplatedTrackCountingComputer< Container, Base >::discriminator().

                                                                      {
     const std::vector<reco::btag::TrackIPData>& impactParameters((tkip.impactParameterData()));
     const Container& tracks(tkip.selectedTracks());
     std::multiset<float> significances;
     int i = 0;
     if (tkip.primaryVertex().isNull()) {
       return std::multiset<float>();
     }
 
     GlobalPoint pv(tkip.primaryVertex()->position().x(),
                    tkip.primaryVertex()->position().y(),
                    tkip.primaryVertex()->position().z());
 
     for (std::vector<reco::btag::TrackIPData>::const_iterator it = impactParameters.begin();
          it != impactParameters.end();
          ++it, i++) {
       if (fabs(impactParameters[i].distanceToJetAxis.value()) < m_cutMaxDistToAxis &&  // distance to JetAxis
           (impactParameters[i].closestToJetAxis - pv).mag() < m_cutMaxDecayLen &&      // max decay len
           (m_useAllQualities == true ||
            reco::btag::toTrack(tracks[i])->quality(m_trackQuality)) &&       // use selected track qualities
           (fabs(((m_ipType == 0) ? it->ip3d : it->ip2d).value()) > m_minIP)  // minimum impact parameter
       ) {
         //calculate the signed or un-signed significance
         float signed_sig = ((m_ipType == 0) ? it->ip3d : it->ip2d).significance();
         float unsigned_sig = fabs(signed_sig);
         float significance = (m_useSignedIPSig) ? signed_sig : unsigned_sig;
 
         if (useVariableJTA_) {
           if (tkip.variableJTA(varJTApars)[i])
             significances.insert(significance);
         } else  // no using variable JTA, use the default method
             if (m_deltaR <= 0 ||
                 ROOT::Math::VectorUtil::DeltaR((*tkip.jet()).p4().Vect(), (*tracks[i]).momentum()) < m_deltaR)
           significances.insert(significance);
       }
     }
 
     return significances;
   }