#include <TemplatedJetBProbabilityComputer.h>

Inheritance diagram for TemplatedJetBProbabilityComputer< Container, Base >:

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

using	Tokens = void

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

double	jetProbability (const std::vector< float > &v) const

	TemplatedJetBProbabilityComputer (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 ()

Private Attributes
double	m_cutMaxDecayLen

double	m_cutMaxDistToAxis

double	m_deltaR

int	m_ipType

double	m_minTrackProb

unsigned int	m_nbTracks

reco::TrackBase::TrackQuality	m_trackQuality

int	m_trackSign

bool	m_useAllQualities

bool	useVariableJTA_

reco::btag::variableJTAParameters	varJTApars

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

void	uses (const std::string &label)

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

Detailed Description

template<class Container, class Base>
class TemplatedJetBProbabilityComputer< Container, Base >

Definition at line 14 of file TemplatedJetBProbabilityComputer.h.

Member Typedef Documentation

◆ TagInfo

template<class Container , class Base >

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

Definition at line 18 of file TemplatedJetBProbabilityComputer.h.

◆ Tokens

template<class Container , class Base >

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

Definition at line 16 of file TemplatedJetBProbabilityComputer.h.

Constructor & Destructor Documentation

◆ TemplatedJetBProbabilityComputer()

template<class Container , class Base >

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

inline

Definition at line 20 of file TemplatedJetBProbabilityComputer.h.

                                                                       {
     m_ipType = parameters.getParameter<int>("impactParameterType");
     m_minTrackProb = parameters.getParameter<double>("minimumProbability");
     m_deltaR = parameters.getParameter<double>("deltaR");
     m_trackSign = parameters.getParameter<int>("trackIpSign");
     m_nbTracks = parameters.getParameter<unsigned int>("numberOfBTracks");
     m_cutMaxDecayLen = parameters.getParameter<double>("maximumDecayLength");
     m_cutMaxDistToAxis = parameters.getParameter<double>("maximumDistanceToJetAxis");
  
     //
     // 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;
  
     useVariableJTA_ = parameters.getParameter<bool>("useVariableJTA");
     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")};
  
     uses("ipTagInfos");
   }

Member Function Documentation

◆ discriminator()

template<class Container , class Base >

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

inlineoverridevirtual

log(all);

Reimplemented from JetTagComputer.

Definition at line 53 of file TemplatedJetBProbabilityComputer.h.

                                                               {
     const TagInfo& tkip = ti.get<TagInfo>();
     const Container& tracks(tkip.selectedTracks());
     const std::vector<float>& allProbabilities((tkip.probabilities(m_ipType)));
     const std::vector<reco::btag::TrackIPData>& impactParameters((tkip.impactParameterData()));
  
     if (tkip.primaryVertex().isNull())
       return 0;
  
     GlobalPoint pv(tkip.primaryVertex()->position().x(),
                    tkip.primaryVertex()->position().y(),
                    tkip.primaryVertex()->position().z());
  
     std::vector<float> probabilities;
     std::vector<float> probabilitiesB;
     int i = 0;
     for (std::vector<float>::const_iterator it = allProbabilities.begin(); it != allProbabilities.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
       ) {
         // Use only positive(or negative) tracks for B
         float p = fabs(*it);
         if (useVariableJTA_) {
           if (tkip.variableJTA(varJTApars)[i]) {
             if (m_trackSign > 0 || *it < 0)
               probabilities.push_back(p);  //Use all tracks for positive tagger and only negative for negative tagger
             if (m_trackSign > 0 && *it >= 0) {
               probabilitiesB.push_back(*it);
             }  //Use only positive tracks for positive tagger
             if (m_trackSign < 0 && *it <= 0) {
               probabilitiesB.push_back(-*it);
             }  //Use only negative tracks for negative tagger
           }
         } else if (m_deltaR < 0 ||
                    ROOT::Math::VectorUtil::DeltaR((*tkip.jet()).p4().Vect(), (*tracks[i]).momentum()) < m_deltaR) {
           //if(m_trackSign>0 || *it >0 ) probabilities.push_back(p); //Use all tracks for positive tagger and only negative for negative tagger
           if (m_trackSign > 0 || *it < 0)
             probabilities.push_back(p);  //Use all tracks for positive tagger and only negative for negative tagger
  
           if (m_trackSign > 0 && *it >= 0) {
             probabilitiesB.push_back(*it);
           }  //Use only positive tracks for positive tagger
           if (m_trackSign < 0 && *it <= 0) {
             probabilitiesB.push_back(-*it);
           }  //Use only negative tracks for negative tagger
         }
       }
     }
  
     float all = jetProbability(probabilities);
     std::sort(probabilitiesB.begin(), probabilitiesB.end());
     if (probabilitiesB.size() > m_nbTracks)
       probabilitiesB.resize(m_nbTracks);
     float b = jetProbability(probabilitiesB);
  
     return -log(b) / 4 - log(all) / 4;  
   }

◆ jetProbability()

template<class Container , class Base >

double TemplatedJetBProbabilityComputer< Container, Base >::jetProbability ( const std::vector< float > & v ) const

inline

Definition at line 113 of file TemplatedJetBProbabilityComputer.h.

                                                          {
     int ngoodtracks = v.size();
     double SumJet = 0.;
  
     for (std::vector<float>::const_iterator q = v.begin(); q != v.end(); q++) {
       SumJet += (*q > m_minTrackProb) ? log(*q) : log(m_minTrackProb);
     }
  
     double ProbJet;
     double Loginvlog = 0;
  
     if (SumJet < 0.) {
       if (ngoodtracks >= 2) {
         Loginvlog = log(-SumJet);
       }
       double Prob = 1.;
       double lfact = 1.;
       for (int l = 1; l != ngoodtracks; l++) {
         lfact *= l;
         Prob += exp(l * Loginvlog - log(1. * lfact));
       }
       double LogProb = log(Prob);
       ProbJet = std::min(exp(std::max(LogProb + SumJet, -30.)), 1.);
     } else {
       ProbJet = 1.;
     }
     if (ProbJet > 1)
       std::cout << "ProbJet too high: " << ProbJet << std::endl;
  
     //double LogProbJet=-log(ProbJet);
     //  //return 1.-ProbJet;
     return ProbJet;
   }