#include <TrackCountingComputer.h>

Inheritance diagram for TrackCountingComputer:

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

	TrackCountingComputer (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 reco::TrackIPTagInfo &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

Definition at line 12 of file TrackCountingComputer.h.

Constructor & Destructor Documentation

TrackCountingComputer::TrackCountingComputer ( const edm::ParameterSet & parameters )

inline

Definition at line 16 of file TrackCountingComputer.h.

References edm::ParameterSet::existsAs(), edm::false, edm::ParameterSet::getParameter(), m_cutMaxDecayLen, m_cutMaxDistToAxis, m_deltaR, m_ipType, m_minIP, m_nthTrack, m_trackQuality, m_useAllQualities, m_useSignedIPSig, reco::TrackBase::qualityByName(), AlCaHLTBitMon_QueryRunRegistry::string, JetTagComputer::uses(), useVariableJTA_, and varJTApars.

   {
     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

float TrackCountingComputer::discriminator ( const TagInfoHelper & ti ) const

inlinevirtual

Reimplemented from JetTagComputer.

Definition at line 53 of file TrackCountingComputer.h.

References JetTagComputer::TagInfoHelper::get(), i, m_nthTrack, and orderedSignificances().

   {           
     const reco::TrackIPTagInfo & tkip = ti.get<reco::TrackIPTagInfo>();
     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.;
   }

std::multiset<float> TrackCountingComputer::orderedSignificances ( const reco::TrackIPTagInfo & tkip ) const

inlineprotected

Definition at line 64 of file TrackCountingComputer.h.

References i, reco::IPTagInfo< Container, Base >::impactParameterData(), PyquenDefaultSettings_cff::impactParameters, edm::Ref< C, T, F >::isNull(), m_minIP, m_useAllQualities, m_useSignedIPSig, p4, reco::IPTagInfo< Container, Base >::primaryVertex(), reco::IPTagInfo< Container, Base >::selectedTracks(), testEve_cfg::tracks, useVariableJTA_, reco::IPTagInfo< Container, Base >::variableJTA(), and varJTApars.

Referenced by NegativeTrackCountingComputer::discriminator(), and discriminator().

                                                                                     {
     
     const std::vector<reco::btag::TrackIPData> & impactParameters((tkip.impactParameterData()));
     const edm::RefVector<reco::TrackCollection> & 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 || (*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;    
   }