#include <TemplatedJetProbabilityComputer.h>

Inheritance diagram for TemplatedJetProbabilityComputer< Container, Base >:

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

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

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

	TemplatedJetProbabilityComputer (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

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 TemplatedJetProbabilityComputer< Container, Base >

Definition at line 15 of file TemplatedJetProbabilityComputer.h.

Member Typedef Documentation

template<class Container , class Base >

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

Definition at line 18 of file TemplatedJetProbabilityComputer.h.

Constructor & Destructor Documentation

template<class Container , class Base >

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

inline

Definition at line 20 of file TemplatedJetProbabilityComputer.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_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 TemplatedJetProbabilityComputer< Container, Base >::discriminator ( const TagInfoHelper & ti ) const

inlinevirtual

Reimplemented from JetTagComputer.

Definition at line 54 of file TemplatedJetProbabilityComputer.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;
       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
         )
          {
           float p;
           if(m_trackSign ==0 )
           { 
            if (*it >=0){p=*it/2.;}else{p=1.+*it/2.;}
           }
           else if(m_trackSign > 0)
           {
             if(*it >=0 ) p=*it; else continue; 
           } else
           {
            if(*it <=0 ) p= -*it; else continue; 
           } 
       if (useVariableJTA_) {
         if (tkip.variableJTA( varJTApars )[i])
           probabilities.push_back(p);
       }else{
         if(m_deltaR <= 0  || ROOT::Math::VectorUtil::DeltaR((*tkip.jet()).p4().Vect(), (*tracks[i]).momentum()) < m_deltaR )
           probabilities.push_back(p);
       }
      }
        }
       return jetProbability(probabilities); 
    }

template<class Container , class Base >

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

inline

Definition at line 98 of file TemplatedJetProbabilityComputer.h.

References gather_cfg::cout, create_public_lumi_plots::exp, prof2calltree::l, cmsBatch::log, TemplatedJetProbabilityComputer< Container, Base >::m_minTrackProb, bookConverter::max, min(), and lumiQueryAPI::q.

Referenced by TemplatedJetProbabilityComputer< 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 -log10(ProbJet)/4.;
   }