#include <TemplatedJetBProbabilityComputer.h>

Inheritance diagram for TemplatedJetBProbabilityComputer< Container, Base >:

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

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 (unsigned int id, const std::string &label)

void	uses (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

template<class Container , class Base >

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

Definition at line 17 of file TemplatedJetBProbabilityComputer.h.

Constructor & Destructor Documentation

template<class Container , class Base >

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

inline

Definition at line 19 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

template<class Container , class Base >

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

inlineoverridevirtual

log(all);

Reimplemented from JetTagComputer.

Definition at line 55 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; 
    }

template<class Container , class Base >

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

inline

Definition at line 105 of file TemplatedJetBProbabilityComputer.h.

References gather_cfg::cout, JetChargeProducer_cfi::exp, checklumidiff::l, cmsBatch::log, TemplatedJetBProbabilityComputer< Container, Base >::m_minTrackProb, SiStripPI::max, min(), and lumiQueryAPI::q.

Referenced by TemplatedJetBProbabilityComputer< Container, Base >::discriminator().

 {
    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;
   }