BTaggingSelectionTool Class Reference

#include <BTaggingSelectionTool.h>

Inheritance diagram for BTaggingSelectionTool:

Collaboration diagram for BTaggingSelectionTool:

Classes
struct	taggerproperties

Public Member Functions
	BTaggingSelectionTool (const std::string &name)
	Create a proper constructor for Athena.
StatusCode	initialize () override
	Dummy implementation of the initialisation function.
virtual asg::AcceptData	accept (const xAOD::IParticle *p) const override
	Get the decision using a generic IParticle pointer.
virtual asg::AcceptData	accept (const xAOD::Jet &jet) const override
virtual asg::AcceptData	accept (double, double, double) const override
	Get the decision using thet jet's pt and tag weight values.
virtual asg::AcceptData	accept (double, double, double, double) const override
virtual asg::AcceptData	accept (double, double, double, double, double) const override
virtual asg::AcceptData	accept (double, double, double, double, double, double) const override
virtual int	getQuantile (const xAOD::IParticle *) const override
	Decide in which quantile of the tag weight distribution the jet belongs (continuous tagging) The return value represents the bin index of the quantile distribution.
virtual int	getQuantile (const xAOD::Jet &) const override
virtual int	getQuantile (double, double, double) const override
virtual int	getQuantile (double, double, double, double) const override
virtual CP::CorrectionCode	getCutValue (double, double &cutval) const override
virtual CP::CorrectionCode	getTaggerWeight (const xAOD::Jet &jet, double &tagweight) const override
virtual CP::CorrectionCode	getTaggerWeight (double pb, double pc, double pu, double &tagweight) const override
virtual CP::CorrectionCode	getTaggerWeight (double pb, double pc, double pu, double &tagweight, double ptau) const override
virtual CP::CorrectionCode	getTaggerWeight (const xAOD::Jet &jet, double &weight, bool getCTagW) const override
virtual CP::CorrectionCode	getTaggerWeight (double, double, double, double &weight, bool getCTagW, double=0.) const override
const asg::AcceptInfo &	getAcceptInfo () const override
	Declare the interface ID for this pure-virtual interface class to the Athena framework.
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
enum	Tagger {   UNKNOWN , DL1 , GN1 , GN2 ,   MV2c10 , GN3EPCLV01 , GN3PflowMuonsV00 }
typedef double(xAOD::BTagging::*	tagWeight_member_t) () const
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
virtual bool	checkRange (double, double, asg::AcceptData &) const
	Helper function that decides whether a jet belongs to the correct jet selection for b-tagging.
void	InitializeTaggerVariables (std::string taggerName, std::string OP, TSpline3 *spline, TVector *constcut, double &fraction)
Tagger	SetTaggerEnum (const std::string &taggerName)
StatusCode	ExtractTaggerProperties (taggerproperties &tagger, const std::string &taggerName, const std::string &OP)
std::vector< std::string >	split (const std::string &input, const char &delimiter)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
bool	m_initialised = false
bool	m_continuous = false
bool	m_continuous2D = false
bool	m_taggerWithTauFractions = true
asg::AcceptInfo	m_acceptinfo
	Object used to store the last decision.
Gaudi::Property< double >	m_minPt {this, "MinPt", 0 , "Minimum jet pT cut (in MeV)"}
Gaudi::Property< double >	m_maxEta {this, "MaxEta", 2.5, "Maximum jet eta cut"}
Gaudi::Property< double >	m_maxRangePt {this, "MaxRangePt", 3000000 , "Max pT range (in MeV)"}
Gaudi::Property< std::string >	m_CutFileName {this, "FlvTagCutDefinitionsFileName", ftag::defaults::cdi_path, "name of the files containing official cut definitions (uses PathResolver)"}
Gaudi::Property< std::string >	m_taggerName {this, "TaggerName", ftag::defaults::tagger, "tagging algorithm name"}
Gaudi::Property< std::string >	m_OP {this, "OperatingPoint", "", "operating point"}
Gaudi::Property< std::string >	m_jetAuthor {this, "JetAuthor", ftag::defaults::jet_collection, "jet collection"}
Gaudi::Property< std::string >	m_ContinuousBenchmarks {this, "CutBenchmarksContinuousWP", "", "comma separated list of tag bins that will be accepted as tagged: 1,2,3 etc.. "}
Gaudi::Property< bool >	m_ErrorOnTagWeightFailure {this, "ErrorOnTagWeightFailure", true, "optionally ignore cases where the tagweight cannot be retrieved. default behaviour is to give an error, switching to false will turn it into a warning"}
Gaudi::Property< bool >	m_useCTag {this, "useCTagging", false, "Enabled only for FixedCut or Continuous WPs: define wether the cuts refer to b-tagging or c-tagging"}
Gaudi::Property< bool >	m_readFromBTaggingObject {this, "readFromBTaggingObject", false, "Enabled to access btagging scores from xAOD::BTagging object; Can be disabled for GN2v01 to access the scores from the jet itself."}
TFile *	m_inf {}
std::vector< double >	m_continuouscuts
SG::AuxElement::ConstAccessor< float >	m_accessor_pb
SG::AuxElement::ConstAccessor< float >	m_accessor_pc
SG::AuxElement::ConstAccessor< float >	m_accessor_pu
SG::AuxElement::ConstAccessor< float >	m_accessor_ptau
taggerproperties	m_tagger
Tagger	m_taggerEnum {UNKNOWN}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 26 of file BTaggingSelectionTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

tagWeight_member_t

typedef double(xAOD::BTagging::* BTaggingSelectionTool::tagWeight_member_t) () const

private

Definition at line 29 of file BTaggingSelectionTool.h.

Member Enumeration Documentation

Tagger

enum BTaggingSelectionTool::Tagger

private

Enumerator
UNKNOWN
DL1
GN1
GN2
MV2c10
GN3EPCLV01
GN3PflowMuonsV00

Definition at line 127 of file BTaggingSelectionTool.h.

{UNKNOWN, DL1, GN1, GN2, MV2c10, GN3EPCLV01, GN3PflowMuonsV00};

Constructor & Destructor Documentation

BTaggingSelectionTool()

BTaggingSelectionTool::BTaggingSelectionTool

(

const std::string &

name

)

Create a proper constructor for Athena.

Create a constructor for standalone usage

Definition at line 43 of file BTaggingSelectionTool.cxx.

  : asg::AsgTool( name ), m_acceptinfo( "JetSelection" ), m_accessor_pb( "pb" ), m_accessor_pc( "pc" ), m_accessor_pu( "pu" ), m_accessor_ptau( "ptau" )
{
  m_initialised = false;
}

Member Function Documentation

accept() [1/6]

asg::AcceptData BTaggingSelectionTool::accept ( const xAOD::IParticle * p ) const

overridevirtual

Get the decision using a generic IParticle pointer.

Implements IBTaggingSelectionTool.

Definition at line 467 of file BTaggingSelectionTool.cxx.

                                                                          {
 
  // Check if this is a jet:
  if( p->type() != xAOD::Type::Jet ) {
    ATH_MSG_ERROR( "accept(...) Function received a non-jet" );
    return asg::AcceptData (&m_acceptinfo);
  }
 
  // Cast it to a jet:
  const xAOD::Jet* jet = dynamic_cast< const xAOD::Jet* >( p );
  if( ! jet ) {
    ATH_MSG_FATAL( "accept(...) Failed to cast particle to jet" );
    return asg::AcceptData (&m_acceptinfo);
  }
 
  // Let the specific function do the work:
  return accept( *jet );
}

accept() [2/6]

asg::AcceptData BTaggingSelectionTool::accept ( const xAOD::Jet & jet ) const

overridevirtual

Implements IBTaggingSelectionTool.

Definition at line 486 of file BTaggingSelectionTool.cxx.

                                                                      {
  asg::AcceptData acceptData (&m_acceptinfo);
 
  if (! m_initialised) {
    ATH_MSG_ERROR("BTaggingSelectionTool has not been initialised");
    return acceptData;
  }
 
  double pT = jet.pt();
  double eta = jet.eta();
 
  if(m_continuous2D){
    double taggerweight_b(-100);
    double taggerweight_c(-100);
    if( (getTaggerWeight( jet, taggerweight_b, false)!=CorrectionCode::Ok) ||
       (getTaggerWeight( jet, taggerweight_c, true )!=CorrectionCode::Ok) )
      return acceptData;
    
    return accept(pT, eta, taggerweight_b,taggerweight_c);
  }
  else{ //if here, we are in 1D mode
    double taggerweight(-100);
    if( getTaggerWeight( jet ,taggerweight, m_useCTag)!=CorrectionCode::Ok)
      return acceptData;
    
    return accept(pT, eta, taggerweight);
  }
}

accept() [3/6]

asg::AcceptData BTaggingSelectionTool::accept ( double pT, double eta, double tag_weight ) const

overridevirtual

Get the decision using thet jet's pt and tag weight values.

Implements IBTaggingSelectionTool.

Definition at line 515 of file BTaggingSelectionTool.cxx.

{
  
  asg::AcceptData acceptData (&m_acceptinfo);
 
  if (! m_initialised) {
    ATH_MSG_ERROR("BTaggingSelectionTool has not been initialised");
    return acceptData;
  }
 
  eta = std::abs(eta);
  if (! checkRange(pT, eta, acceptData))
    return acceptData;
 
  // After initialization, either m_tagger.spline or m_tagger.constcut should be non-zero
  // Else, the initialization was incorrect and should be revisited
  if(m_continuous){
    for(size_t bin : m_tagger.benchmarks){
      if(bin == 0){
          throw std::logic_error("bin == 0 in the list of tagged bins. you should not be here. Wrong convention");
      } else if ( bin == 1 ) {
        if ( tag_weight < m_continuouscuts.at(bin-1) ) {
          acceptData.setCutResult( "WorkingPoint", true );
        }
      } else if (bin > 1 && bin <= m_continuouscuts.size()){
        if ( tag_weight > m_continuouscuts.at(bin-2) && tag_weight < m_continuouscuts.at(bin-1) ) {
          acceptData.setCutResult( "WorkingPoint", true );
        }
      } else {
        if ( tag_weight > m_continuouscuts.at(bin-2) ) {
          acceptData.setCutResult( "WorkingPoint", true );
        }
      }
    }
  }
  else{ //FixedCut
    double cutvalue(DBL_MAX);
    if( getCutValue(pT, cutvalue )!=CorrectionCode::Ok ){
      return acceptData;
    }
    
    if ( tag_weight < cutvalue ){
      return acceptData;
    }
    
    acceptData.setCutResult( "WorkingPoint", true );
  }
  
  // Return the result:
  return acceptData;
}

accept() [4/6]

asg::AcceptData BTaggingSelectionTool::accept ( double pT, double eta, double taggerWeight_b, double taggerWeight_c ) const

overridevirtual

Implements IBTaggingSelectionTool.

Definition at line 567 of file BTaggingSelectionTool.cxx.

{
  asg::AcceptData acceptData (&m_acceptinfo);
 
  if (! m_initialised) {
    ATH_MSG_ERROR("BTaggingSelectionTool has not been initialised");
    return acceptData;
  }
 
  eta = std::abs(eta);
 
  if (! checkRange(pT, eta, acceptData))
    return acceptData;
 
  for(auto bin : m_tagger.benchmarks){
 
    ATH_MSG_DEBUG("bin" <<bin <<" taggerWeight_c " 
          <<taggerWeight_c <<" taggerWeight_b " 
          <<taggerWeight_b);
    
    ATH_MSG_DEBUG(" c-cuts : " <<m_tagger.get2DCutValue(bin,0) <<" " 
          <<m_tagger.get2DCutValue(bin,1) <<" b-cuts : " 
          <<m_tagger.get2DCutValue(bin,2) <<" " 
          <<m_tagger.get2DCutValue(bin,3));
    
    if (taggerWeight_c >  m_tagger.get2DCutValue(bin,0) &&  //ctag low
    taggerWeight_c <= m_tagger.get2DCutValue(bin,1) &&  //ctag max
    taggerWeight_b >  m_tagger.get2DCutValue(bin,2) &&  //btag low
    taggerWeight_b <= m_tagger.get2DCutValue(bin,3)  )  //btag max
      {
    acceptData.setCutResult( "WorkingPoint", true ); // IF we arrived here, the jet is tagged
    break;  
      }
  } //for loop
 
  // Return the result:
  return acceptData;
}

accept() [5/6]

asg::AcceptData BTaggingSelectionTool::accept ( double pT, double eta, double pb, double pc, double pu ) const

overridevirtual

Implements IBTaggingSelectionTool.

Definition at line 606 of file BTaggingSelectionTool.cxx.

{
  if (m_taggerWithTauFractions){
    asg::AcceptData acceptData (&m_acceptinfo);
    ATH_MSG_ERROR("For GN2v01 and GN3 taggers, there is a new tau class in the NN output. Please update the accept() to accept(double pT, double eta, double pb, double pc, double pu, double ptau)");
    return acceptData;
  } else {
    return accept(pT, eta, pb, pc, pu, 0.);
  }
}

accept() [6/6]

asg::AcceptData BTaggingSelectionTool::accept ( double pT, double eta, double pb, double pc, double pu, double ptau ) const

overridevirtual

Implements IBTaggingSelectionTool.

Definition at line 617 of file BTaggingSelectionTool.cxx.

 {
   asg::AcceptData acceptData (&m_acceptinfo);
 
   if (! m_initialised) {
     ATH_MSG_ERROR("BTaggingSelectionTool has not been initialised");
     return acceptData;
   }
 
   eta = std::abs(eta);
   if (! checkRange(pT, eta, acceptData))
     return acceptData;
 
   // After initialization, either m_tagger.spline or m_tagger.constcut should be non-zero
   // Else, the initialization was incorrect and should be revisited
   double cutvalue(DBL_MAX);
 
   if( getCutValue(pT, cutvalue)!=CorrectionCode::Ok){
    return acceptData;
   };
  
   if(m_continuous2D){
     double tagger_weight_b(-100);
     double tagger_weight_c(-100);
     if( ( getTaggerWeight(pb, pc, pu, tagger_weight_b, false, ptau)!=CorrectionCode::Ok) ||
         ( getTaggerWeight(pb, pc, pu, tagger_weight_c, true, ptau)!=CorrectionCode::Ok) )
       return acceptData;
     return accept(pT, eta, tagger_weight_b, tagger_weight_c);
   }
   else{
     double tagger_weight(-100);
     if( getTaggerWeight(pb, pc, pu, tagger_weight, m_useCTag, ptau)!=CorrectionCode::Ok)
       return acceptData;
     if ( tagger_weight < cutvalue )
       return acceptData;
   }
   //if you made it here, the jet is tagged
   acceptData.setCutResult( "WorkingPoint", true );
   return acceptData;
 }

checkRange()

bool BTaggingSelectionTool::checkRange ( double pT, double eta, asg::AcceptData & acceptData ) const

privatevirtual

Helper function that decides whether a jet belongs to the correct jet selection for b-tagging.

Definition at line 792 of file BTaggingSelectionTool.cxx.

{
  // Do the |eta| cut:
  if( std::abs(eta) > m_maxEta ) {
    return false;
  }
  acceptData.setCutResult( "Eta", true );
 
  // Do the pT cut:
  ATH_MSG_VERBOSE( "Jet pT: " << pT );
  if( pT < m_minPt ) {
    return false;
  }
  acceptData.setCutResult( "Pt", true );
 
  return true;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

ExtractTaggerProperties()

StatusCode BTaggingSelectionTool::ExtractTaggerProperties ( taggerproperties & tagger, const std::string & taggerName, const std::string & OP )

private

Definition at line 246 of file BTaggingSelectionTool.cxx.

                                                                                                                                   {
 
  TString cutname = OP;
 
  //set the name
  tagger.name = taggerName;
 
  if ("FlatBEff"==cutname(0,8) || "HybBEff"==cutname(0,7) ){
    cutname = taggerName+"/"+m_jetAuthor+"/"+OP+"/cutprofile";
    tagger.spline = dynamic_cast<TSpline3*> (m_inf->Get(cutname));
    if (tagger.spline == nullptr){
      ATH_MSG_ERROR( "Invalid operating point" );
      return StatusCode::FAILURE;
    }
    tagger.constcut = nullptr;
  }
  else {
    cutname = taggerName+"/"+m_jetAuthor+"/"+OP+"/cutvalue";
    tagger.constcut = dynamic_cast<TVector*> (m_inf->Get(cutname));
    if (tagger.constcut == nullptr){ 
      ATH_MSG_ERROR( "Invalid operating point" );
      return StatusCode::FAILURE;
    }
    tagger.spline = nullptr;
  }
 
  //retrieve the "fraction" used in the DL1 log likelihood from the CDI, if its not there, use the hard coded values
  // (backwards compatibility)
  if( m_taggerEnum != Tagger::MV2c10 ){
    
    double fraction_b = -1;
    const TString basePath = taggerName + "/" + m_jetAuthor + "/" + OP;
    TVector* fraction_b_data = dynamic_cast<TVector*>( m_inf->Get(basePath + "/fraction_b") );
    if (fraction_b_data) {
        fraction_b = (*fraction_b_data)(0);
    }
    
    TVector* fraction_c_data = dynamic_cast<TVector*>( m_inf->Get(basePath + "/fraction") );
    if (!fraction_c_data) {
        fraction_c_data = dynamic_cast<TVector*>( m_inf->Get(basePath + "/fraction_c") );
    }
    double fraction_c = -1;
    if (fraction_c_data) {
      fraction_c = (*fraction_c_data)(0);
    } else{
      if("DL1"    ==taggerName){ fraction_c = 0.08; }
      if("DL1mu"  ==taggerName){ fraction_c = 0.08; }
      if("DL1rnn" ==taggerName){ fraction_c = 0.03; }
      else {
        ATH_MSG_ERROR("Failed to retrieve fraction_c");
      }
    }
 
    double fraction_tau = 0.;
    double fraction_tau_cTag = 0.;
    TVector* fraction_tau_data = dynamic_cast<TVector*>( m_inf->Get(basePath + "/fraction_tau") );
    TVector* fraction_tau_cTag_data = dynamic_cast<TVector*>( m_inf->Get(basePath + "/fraction_tau_cTag") );
    if (m_taggerWithTauFractions){
      if( fraction_tau_data ) {
        fraction_tau = fraction_tau_data[0](0);
      }
      if ( m_useCTag && !fraction_tau_cTag_data) {
        ATH_MSG_ERROR("Runnint c-tagging WP, but failed to retrive fraction_tau_cTag");
        return StatusCode::FAILURE;
      }    
      fraction_tau_cTag = fraction_tau_cTag_data[0](0);
 
      if (!fraction_tau_data && !fraction_tau_cTag){
      // For all recent taggers GN2v01 or above, the tau fraction(s) should be saved in the CDI file and retrieved/set within the BTaggingSelectionTool
      // Hence raising error and failure here as at least one of those fractions should not be a null pointer
      ATH_MSG_ERROR("Tau-fraction(s) should have been retrieved for taggerName=" << taggerName << " but both fraction_tau_data and fraction_tau_cTag are null pointers");
      return StatusCode::FAILURE;
    }
    tagger.fraction_b = fraction_b;
    tagger.fraction_c = fraction_c;
    tagger.fraction_tau = fraction_tau;
    tagger.fraction_tau_cTag = fraction_tau_cTag;
 
    delete fraction_b_data;
    delete fraction_c_data;
    delete fraction_tau_data;
    delete fraction_tau_cTag_data;
    }
  }
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

getAcceptInfo()

const asg::AcceptInfo & BTaggingSelectionTool::getAcceptInfo ( ) const

inlineoverridevirtual

Declare the interface ID for this pure-virtual interface class to the Athena framework.

Method to get the AcceptInfo to query what cuts are defined.

Implements IAsgSelectionTool.

Definition at line 65 of file BTaggingSelectionTool.h.

{return m_acceptinfo;} 

getCutValue()

CorrectionCode BTaggingSelectionTool::getCutValue ( double pT, double & cutval ) const

overridevirtual

Implements IBTaggingSelectionTool.

Definition at line 810 of file BTaggingSelectionTool.cxx.

{
   cutval = DBL_MAX;
 
   // flat cut for out of range pTs
   if (pT>m_maxRangePt)
     pT = m_maxRangePt;
 
   taggerproperties tagger ATLAS_THREAD_SAFE = m_tagger;
 
   if (tagger.spline != nullptr && tagger.constcut == nullptr) {
     pT = pT/1000.0;
     double maxsplinept = tagger.spline->GetXmax();
     if (pT>maxsplinept){ pT = maxsplinept; }
     cutval = tagger.spline->Eval(pT);
   }
 
   else if (tagger.constcut != nullptr && tagger.spline == nullptr) {
     cutval = tagger.constcut[0](0);
   }
   else{
    ATH_MSG_ERROR( "Bad cut configuration!" );
    return CorrectionCode::Error;
   }
 
 
   ATH_MSG_VERBOSE( "Cut value " << cutval );
 
   return CorrectionCode::Ok;
}

getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void * ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::Event both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::Event, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

getName()

const std::string & asg::AsgTool::getName ( const void * ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::Event both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::Event, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

getProperty()

template<class T>

const T * asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

getQuantile() [1/4]

int BTaggingSelectionTool::getQuantile ( const xAOD::IParticle * p ) const

overridevirtual

Decide in which quantile of the tag weight distribution the jet belongs (continuous tagging) The return value represents the bin index of the quantile distribution.

Implements IBTaggingSelectionTool.

Definition at line 658 of file BTaggingSelectionTool.cxx.

                                                                     {
  // Check if this is a jet:
 
 
  if( p->type() != xAOD::Type::Jet ) {
    ATH_MSG_ERROR( "accept(...) Function received a non-jet" );
    return -1;
  }
 
  // Cast it to a jet:
  const xAOD::Jet* jet = dynamic_cast< const xAOD::Jet* >( p );
  if( ! jet ) {
    ATH_MSG_FATAL( "accept(...) Failed to cast particle to jet" );
    return -1;
  }
 
  // Let the specific function do the work:
  return getQuantile( *jet );
}

getQuantile() [2/4]

int BTaggingSelectionTool::getQuantile ( const xAOD::Jet & jet ) const

overridevirtual

Implements IBTaggingSelectionTool.

Definition at line 678 of file BTaggingSelectionTool.cxx.

                                                                {
  double pT = jet.pt();
  double eta = std::abs( jet.eta() );
  int quantile = -1;
  
  if (m_continuous2D){
    double tag_weight_b(-100.);
    double tag_weight_c(-100.);
    if ( (getTaggerWeight(jet, tag_weight_b, false) == CP::CorrectionCode::Error) ||
         (getTaggerWeight(jet, tag_weight_c, true ) == CP::CorrectionCode::Error) ){
      ATH_MSG_WARNING("getQuantile: Failed to retrieve tag weight for Continuous2D!");
      return -1;
    }
    quantile = getQuantile(pT, eta, tag_weight_b, tag_weight_c );
  }
  else{
    // Retrieve the tagger weight which was assigned to the jet
    double tag_weight(-100.);
    if (getTaggerWeight(jet, tag_weight, m_useCTag)==CorrectionCode::Error){
      ATH_MSG_WARNING("getQuantile: Failed to retrieve "+m_taggerName+" weight!");
      return -1;
    }
    ATH_MSG_VERBOSE( m_taggerName << " " <<  tag_weight);
    quantile = getQuantile(pT, eta, tag_weight);
  }
  return quantile;
}

getQuantile() [3/4]

int BTaggingSelectionTool::getQuantile ( double pT, double eta, double tag_weight ) const

overridevirtual

Implements IBTaggingSelectionTool.

Definition at line 707 of file BTaggingSelectionTool.cxx.

{
  if (! m_initialised) {
    ATH_MSG_ERROR("BTaggingSelectionTool has not been initialised");
  }
  // Cheatsheet:
  // With n WPs,  (from highest to lowest) A1 , A2, A3, ..., An
  // return -1 if not in b-tagging acceptance
  // return  1 if between 100% and A1 (untagged)
  // return  2 if between A1   and A2 (tagged at the A1 WP)
  // return  3 if between A2   and A3 (tagged at the A2 WP)
  // ...
  // return n   if between An-1 and An (tagged at the An-1 WP)
  // return n+1 if between An   and 0% (tagged at the An WP)
 
  int bin_index = -1;
 
  // First, check if the jet is in acceptance
  asg::AcceptData acceptData (&m_acceptinfo);
  if (! checkRange(pT, eta,acceptData)) {
    return bin_index;
  }
 
  // Now we need to check each threshold in the PCBT vector
  // and return the maximum WP bin index (1,2,...,n).
  // Instead of checking low<tag_weight<high for each bin,
  // we simply check tag_weight<high and therefore range
  // from vector indices 1 to vector.size()
  bin_index = 1; // setting the ones that pass selection you have default as 1
  for (std::size_t i=0; i<m_continuouscuts.size(); i++) {
    if ( tag_weight > m_continuouscuts.at(i) ) {
      bin_index++;
    } else {
      break;
    }
  }
  return bin_index;
}

getQuantile() [4/4]

int BTaggingSelectionTool::getQuantile ( double pT, double eta, double tag_weight_b, double tag_weight_c ) const

overridevirtual

Cheatsheet: returns 4 if pass B_tight (?) returns 3 if pass B_loose returns 2 if pass C_tight + fail B_loose returns 1 if pass C_loose + fail C_tight + fail B_loose returns 0 if fail C_loose + fail B_loose return -1 not in b-tagging acceptance

Implements IBTaggingSelectionTool.

Definition at line 748 of file BTaggingSelectionTool.cxx.

{
 
  //More details here: https://indico.cern.ch/event/1116952/#4-mr49953-implements-the-conti
 
  ATH_MSG_DEBUG("inside getQuantile 2D " <<pT <<" " <<eta <<" " <<tag_weight_b <<" " <<tag_weight_c);
  int bin_index(-1);
 
  asg::AcceptData acceptData (&m_acceptinfo);
  if (! checkRange(pT, eta, acceptData)) return bin_index;
 
  int ncuts = m_tagger.cuts2D->GetNrows();
  ATH_MSG_VERBOSE("ncuts: " <<ncuts);
 
  //loop over all the cuts
  for(int i = 0; i < ncuts ; i++){
    double c_cut_low = m_tagger.get2DCutValue(i,0);
    double c_cut_hig = m_tagger.get2DCutValue(i,1);
    double b_cut_low = m_tagger.get2DCutValue(i,2);
    double b_cut_hig = m_tagger.get2DCutValue(i,3);
 
    ATH_MSG_DEBUG("bin " <<i <<" c_cut low " <<c_cut_low <<" c_cut hig " <<c_cut_hig <<" c_cut low " <<b_cut_low <<" b_ct hig" <<b_cut_hig);
    if (tag_weight_c >  c_cut_low && 
    tag_weight_c <= c_cut_hig &&
    tag_weight_b >  b_cut_low && 
    tag_weight_b <= b_cut_hig){
      bin_index = i;
      break;
    }
  }
    
  ATH_MSG_VERBOSE("bin_index " <<bin_index);
  return bin_index;
}

getTaggerWeight() [1/5]

CorrectionCode BTaggingSelectionTool::getTaggerWeight ( const xAOD::Jet & jet, double & tagweight ) const

overridevirtual

Implements IBTaggingSelectionTool.

Definition at line 333 of file BTaggingSelectionTool.cxx.

                                                                                                  {
  return getTaggerWeight(jet, tagweight, m_useCTag);
}

getTaggerWeight() [2/5]

CorrectionCode BTaggingSelectionTool::getTaggerWeight ( const xAOD::Jet & jet, double & weight, bool getCTagW ) const

overridevirtual

Implements IBTaggingSelectionTool.

Definition at line 337 of file BTaggingSelectionTool.cxx.

                                                                                                                 {
 
  std::string taggerName = m_tagger.name;
  // following taggerName change is needed given different name is used for GN2v00 in derivation and in CDI
  if (taggerName == "GN2v00LegacyWP" || taggerName == "GN2v00NewAliasWP"){
      taggerName = "GN2v00";
  }
  
  tagweight = -100.;
 
   if(!m_continuous2D && (getCTagW != m_useCTag) ){
    ATH_MSG_ERROR("Difference between initialisation and getTaggerWeight request! useCTagging property set to " <<m_useCTag <<" while getTaggerWeight use c-tag is set to " <<getCTagW <<".");
    return CorrectionCode::Error;
  }
 
  if ( m_taggerEnum == Tagger::MV2c10 ){
 
    const xAOD::BTagging* btag = xAOD::BTaggingUtilities::getBTagging( jet );
 
    if ((!btag) || (!btag->MVx_discriminant(taggerName, tagweight))){
      if(m_ErrorOnTagWeightFailure){
        ATH_MSG_ERROR("Failed to retrieve "+taggerName+" weight!");
        return CorrectionCode::Error;
      }else{
        ATH_MSG_WARNING("Failed to retrieve "+taggerName+" weight!");
        return CorrectionCode::Ok;
      }
    }
    ATH_MSG_VERBOSE( taggerName << " " <<  tagweight );
    return  CorrectionCode::Ok;
  } //MV2
  else{ 
    //DL1r or DL1 or GN2v01
  double tagger_pb(-10.);
  double tagger_pc(-10.);
  double tagger_pu(-10.);
  double tagger_ptau(0.);
 
  const SG::AuxElement* btagInfo = &jet;
  if(m_readFromBTaggingObject)
      btagInfo = xAOD::BTaggingUtilities::getBTagging(jet);
  
  if(!btagInfo){
      if(m_ErrorOnTagWeightFailure){
          ATH_MSG_ERROR("Failed to retrieve "+taggerName+" weight!");
          return CorrectionCode::Error;
      }else{
          ATH_MSG_WARNING("Failed to retrieve "+taggerName+" weight!");
          return CorrectionCode::Ok;
      }
  }
 
  tagger_pb = m_accessor_pb(*btagInfo);  
  tagger_pc = m_accessor_pc(*btagInfo);  
  tagger_pu = m_accessor_pu(*btagInfo);  
  if(m_taggerWithTauFractions){
      tagger_ptau = m_accessor_ptau(*btagInfo);  
  }
 
   return getTaggerWeight(tagger_pb, tagger_pc, tagger_pu, tagweight, getCTagW, tagger_ptau);
 
  }
 
  //if we got here the tagger name is not configured properly
  ATH_MSG_ERROR("BTaggingSelectionTool doesn't support tagger: "+m_taggerName);
  return CorrectionCode::Error;
 
}

getTaggerWeight() [3/5]

CorrectionCode BTaggingSelectionTool::getTaggerWeight ( double pb, double pc, double pu, double & tagweight ) const

overridevirtual

Implements IBTaggingSelectionTool.

Definition at line 406 of file BTaggingSelectionTool.cxx.

                                                                                                               {
  if (m_taggerWithTauFractions){
    ATH_MSG_ERROR("For GN2v01 or newer taggers, there is a new tau class in the NN output. Please update your getTaggerWeight() to getTaggerWeight( double pb, double pc, double pu, double & tagweight, double ptau)");
    return CorrectionCode::Error;
  } else {
    return getTaggerWeight(pb, pc, pu, tagweight, m_useCTag, 0.);
  }
}

getTaggerWeight() [4/5]

CorrectionCode BTaggingSelectionTool::getTaggerWeight ( double pb, double pc, double pu, double & tagweight, double ptau ) const

overridevirtual

Implements IBTaggingSelectionTool.

Definition at line 415 of file BTaggingSelectionTool.cxx.

                                                                                                                            {
  return getTaggerWeight(pb, pc, pu, tagweight, m_useCTag, ptau);
}

getTaggerWeight() [5/5]

CorrectionCode BTaggingSelectionTool::getTaggerWeight ( double pb, double pc, double pu, double & weight, bool getCTagW, double ptau = 0. ) const

overridevirtual

Implements IBTaggingSelectionTool.

Definition at line 419 of file BTaggingSelectionTool.cxx.

                                                                                                                                            {
 
  std::string taggerName = m_tagger.name;
 
  if(!m_continuous2D && (getCTagW != m_useCTag) ){
    ATH_MSG_ERROR("Difference between initialisation and getTaggerWeight request! useCTagging property set to " <<m_useCTag <<" while getTaggerWeight use c-tag is set to " <<getCTagW <<".");
    return CorrectionCode::Error;
  }
 
  tagweight = -100.;
  if( m_taggerEnum != Tagger::MV2c10 ){
 
    bool valid_input = (!std::isnan(pu) && pb>=0 && pc>=0 && pu>=0 && ptau>=0);
 
    if (!valid_input){
      if(m_ErrorOnTagWeightFailure){
        ATH_MSG_ERROR("Invalid inputs for "+taggerName+" pb " << pb << " pc " << pc << " pu " << pu << " ptau " << ptau << " ");
        return CorrectionCode::Error;
      }else{
        ATH_MSG_WARNING("Invalid inputs for "+taggerName+" pb " << pb << " pc " << pc << " pu " << pu << " ptau " << ptau << " ");
        return CorrectionCode::Ok;
      }
    }
 
    if(getCTagW){
     tagweight = log(pc / (m_tagger.fraction_b * pb + (1. - m_tagger.fraction_b - m_tagger.fraction_tau_cTag) * pu + m_tagger.fraction_tau_cTag * ptau) );
    }
    else{
     tagweight = log(pb / (m_tagger.fraction_c * pc + (1. - m_tagger.fraction_c - m_tagger.fraction_tau) * pu + m_tagger.fraction_tau * ptau) );
    }
 
    ATH_MSG_VERBOSE( "pb " <<  pb );
    ATH_MSG_VERBOSE( "pc " <<  pc );
    ATH_MSG_VERBOSE( "pu " <<  pu );
    ATH_MSG_VERBOSE( "ptau" << ptau );
    ATH_MSG_VERBOSE( "tagweight " <<  tagweight );
 
    return CorrectionCode::Ok;
  }
 
  //if we got here the tagger name is not configured properly
  ATH_MSG_ERROR("this call to getTaggerWeight only works for DL1/GNx taggers");
  return CorrectionCode::Error;
 
}

initialize()

StatusCode BTaggingSelectionTool::initialize ( void )

overridevirtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from asg::AsgTool.

Definition at line 49 of file BTaggingSelectionTool.cxx.

                                             {
  m_initialised = true;
 
  if (m_OP == ""){
    ATH_MSG_ERROR( "BTaggingSelectionTool wasn't given a working point name" );
    return StatusCode::FAILURE;
  }
 
  TString pathtofile =  PathResolverFindCalibFile(m_CutFileName);
  m_inf = TFile::Open(pathtofile, "read");
  if (0==m_inf) {
    ATH_MSG_ERROR( "BTaggingSelectionTool couldn't access the CDI file" );
    return StatusCode::FAILURE;
  }
 
  // check the CDI file for the selected tagger and jet collection
  TString check_CDI = m_taggerName.value();
  if(!m_inf->Get(check_CDI)){
    ATH_MSG_ERROR( "Tagger: "+m_taggerName+" not found in this CDI file: "+m_CutFileName);
    return StatusCode::FAILURE;
  }
  check_CDI = m_taggerName+"/"+m_jetAuthor;
  if(!m_inf->Get(check_CDI)){
    ATH_MSG_ERROR( "Tagger: "+m_taggerName+" and Jet Collection : "+m_jetAuthor+"  not found in this CDI file: "+m_CutFileName);
    return StatusCode::FAILURE;
  }
 
  //set taggerEnum to avid string comparison:
  m_taggerEnum = SetTaggerEnum(m_taggerName);
  
  // For all recent taggers (GN2v01 or above), the tau fraction(s) should be saved in the CDI file and retrieved/set within the BTaggingSelectionTool
  // This boolean allows the tool knowing if we expect tau fractions or no for the tagger the user wants to use
  m_taggerWithTauFractions = (m_taggerEnum != Tagger::MV2c10 && m_taggerEnum != Tagger::DL1 && m_taggerEnum != Tagger::GN1 && !(m_taggerName.value().find("GN2v00") != std::string::npos)); 
 
 // Change the minPt cut if the user didn't touch it
 if (m_minPt < 0){
    ATH_MSG_ERROR( "Tagger: "+m_taggerName+" and Jet Collection : "+m_jetAuthor+" do not have a minimum jet pT cut set.");
    return StatusCode::FAILURE;
 }
 
 // Operating point reading
 TString cutname = m_OP.value();
 m_continuous   = false;
 m_continuous2D = false;
 
 if(cutname.Contains("Continuous2D")){
   ATH_MSG_INFO("Working with Continuous2D WP.");
   m_continuous   = true;
   m_continuous2D = true; 
   m_useCTag      = false; //important for backward compatibility in getTaggerWeight methods.
   cutname = m_taggerName+"/"+m_jetAuthor+"/Continuous2D/cutvalue";
   m_tagger.name = m_taggerName;
   TMatrixD* matrix = dynamic_cast<TMatrixD*> (m_inf->Get(cutname));
   m_tagger.cuts2D = matrix;
 
   for (int bin = 0; bin < m_tagger.cuts2D->GetNrows(); bin++)
     ATH_MSG_DEBUG("INITIALIZATION c-cuts : " <<m_tagger.get2DCutValue(bin,0) <<" "
           <<m_tagger.get2DCutValue(bin,1) <<" b-cuts : "
           <<m_tagger.get2DCutValue(bin,2) <<" "
           <<m_tagger.get2DCutValue(bin,3));
   
   if (m_tagger.cuts2D == nullptr){
     ATH_MSG_ERROR( "Invalid operating point" );
     return StatusCode::FAILURE;
   }
   
   m_tagger.spline = nullptr;
   
   TString fraction_data_name = m_taggerName+"/"+m_jetAuthor+"/Continuous2D/fraction_b";
   TVector *fraction_data = dynamic_cast<TVector*> (m_inf->Get(fraction_data_name));
   if(fraction_data!=nullptr){
     m_tagger.fraction_b = fraction_data[0](0);
   }
   else{
     ATH_MSG_ERROR("Tagger fraction_b in Continuous2D WP not available");
     return StatusCode::FAILURE;
   }
   
   //now the c-fraction:
   fraction_data_name = m_taggerName+"/"+m_jetAuthor+"/Continuous2D/fraction_c";
   fraction_data = dynamic_cast<TVector*> (m_inf->Get(fraction_data_name));
   if(fraction_data!=nullptr){
     m_tagger.fraction_c = fraction_data[0](0);}
   else{
     ATH_MSG_ERROR("Tagger fraction_c in Continuous2D WP not available");
     return StatusCode::FAILURE;
   }
   //now the tau-fraction if the tagger is GN2* or GN3*:
   if ( m_taggerWithTauFractions ){
     fraction_data_name = m_taggerName+"/"+m_jetAuthor+"/Continuous2D/fraction_tau";
     TString fraction_data_name_cTag = m_taggerName+"/"+m_jetAuthor+"/Continuous2D/fraction_tau_cTag";
     fraction_data = dynamic_cast<TVector*> (m_inf->Get(fraction_data_name));
     TVector *fraction_data_cTag = dynamic_cast<TVector*> (m_inf->Get(fraction_data_name_cTag));
     if(fraction_data!=nullptr){
       m_tagger.fraction_tau = fraction_data[0](0);
     }else{
       ATH_MSG_ERROR("Tagger fraction_tau in Continuous2D WP not available");
       return StatusCode::FAILURE;
     }
     if(fraction_data_cTag!=nullptr){
       m_tagger.fraction_tau_cTag = fraction_data_cTag[0](0);
     }else{
       ATH_MSG_ERROR("Tagger fraction_tau_cTag in Continuous2D WP not available");
       return StatusCode::FAILURE;
     }
     delete fraction_data_cTag;
   }
   delete fraction_data;
 } //Continuous2D
 else if ("Continuous"==cutname(0,10)){ // For continuous tagging load all flat-cut WPs
      if(m_useCTag)
      ATH_MSG_WARNING( "Running in Continuous WP and using 1D c-tagging");
      m_continuous   = true;
 
      std::string subDirName = m_taggerName + "/" + m_jetAuthor;
      // Get directory containing the cuts information 
      TDirectoryFile *tmpDir = dynamic_cast<TDirectoryFile*>( m_inf->Get(subDirName.c_str()) );
      if (!tmpDir){
        // Raise error if could not retrieve subdirectory 
        ATH_MSG_ERROR( "CDI file does not contain sub-directory: " << subDirName );
        return StatusCode::FAILURE;
      }
      
      // Now retrieve the name of the b-tagging fixed cut efficiency working points 
      static const std::string fixedBCutPrefix = "FixedCutBEff_";
      std::vector<std::string> workingpoints;
      
      // Loop over keys in the sub directory and select the ones corresponding to fixed cuts 
      TIter next(tmpDir->GetListOfKeys());
      TKey *key;
      while ((key = (TKey*)next())) {
        std::string keyName = key->GetName();
        // Check if key begins with prefix in that case it's one of the working point
        // Also make sure the key is not already in the vector as 
        // the list of keys from GetListOfKeys() can contain several times the same name
        // because there can be several cycle number per objects
        // since here we check the entry is not already in the vector it's fine 
        // See
        // https://root-forum.cern.ch/t/tkey-tobject-and-getlistofkeys-for-only-newest-ttrees/25928/3
        // https://root-forum.cern.ch/t/tkey-tobject-and-getlistofkeys-for-only-newest-ttrees/25928/7
        if (keyName.starts_with(fixedBCutPrefix) && 
            std::find(workingpoints.begin(), workingpoints.end(), keyName) == workingpoints.end()){
            // Add efficiency working point to the vector 
            workingpoints.push_back( keyName );
        }
      }
      
      // After having retrieved all b-tagging working points 
      // Sort vector then set descending order i.e. loosest working point first 
      std::sort(workingpoints.begin(), workingpoints.end());
      std::reverse(workingpoints.begin(), workingpoints.end()); // put in descending order
      for(const std::string& wp : workingpoints){
        cutname = subDirName + "/" + wp + "/cutvalue";
        m_tagger.constcut = dynamic_cast<TVector*> (m_inf->Get(cutname));
        if (m_tagger.constcut != nullptr) {
          m_continuouscuts.push_back(m_tagger.constcut[0](0));
        } else {
          ATH_MSG_ERROR( "Continuous tagging is trying to use an invalid operating point: " + wp );
          return StatusCode::FAILURE;
        }
      }
 
      //The WP is not important. This is just to retrieve the c-fraction. 
      ANA_CHECK(ExtractTaggerProperties(m_tagger, m_taggerName, workingpoints.at(0)));
 
 } else {
    if(m_useCTag){
      ATH_MSG_WARNING( "Running in FixedCut WP for c-tagging, make sure to use  b-veto to select c-tagged jet properly.");
    }
    ANA_CHECK(ExtractTaggerProperties(m_tagger,m_taggerName, m_OP));
 }
 
 //set the accept working points, jets in these pseudo-continuous bins will be accepted
 if(m_continuous){
   std::vector<std::string> tag_benchmarks_names = split(m_ContinuousBenchmarks, ',');
   std::vector<int> tag_benchmarks;
   for (const std::string& tagbin : tag_benchmarks_names){
     tag_benchmarks.push_back(std::atoi(tagbin.c_str()));
     ATH_MSG_INFO("adding " <<tag_benchmarks.back() <<" as tagged bin ");
   }
   m_tagger.benchmarks = tag_benchmarks;
 }
 
 m_inf->Close();
 
 m_acceptinfo.addCut( "Eta", "Selection of jets according to their pseudorapidity" );
 m_acceptinfo.addCut( "Pt",  "Selection of jets according to their transverse momentum" );
 m_acceptinfo.addCut( "WorkingPoint",  "Working point for flavour-tagging of jets according to their b-tagging weight" );
 
 m_accessor_pb = SG::AuxElement::ConstAccessor<float>(m_taggerName+ "_pb");
 m_accessor_pc = SG::AuxElement::ConstAccessor<float>(m_taggerName+ "_pc");
 m_accessor_pu = SG::AuxElement::ConstAccessor<float>(m_taggerName+ "_pu");
 m_accessor_ptau = SG::AuxElement::ConstAccessor<float>(m_taggerName+ "_ptau");
 
 return StatusCode::SUCCESS;
}

InitializeTaggerVariables()

void BTaggingSelectionTool::InitializeTaggerVariables ( std::string taggerName, std::string OP, TSpline3 * spline, TVector * constcut, double & fraction )

private

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

SetTaggerEnum()

Tagger BTaggingSelectionTool::SetTaggerEnum ( const std::string & taggerName )

inlineprivate

Definition at line 130 of file BTaggingSelectionTool.h.

                                                   {
    if(taggerName.find("DL1") != std::string::npos) return Tagger::DL1;
    else if(taggerName.find("GN1") != std::string::npos) return Tagger::GN1;
    else if(taggerName.find("GN2") != std::string::npos) return Tagger::GN2;
    else if(taggerName.find("GN3EPCLV01") != std::string::npos) return Tagger::GN3EPCLV01;
    else if(taggerName.find("GN3PflowMuonsV00") != std::string::npos) return Tagger::GN3PflowMuonsV00;
    else if(taggerName == "MV2c10") return Tagger::MV2c10;
    else 
      ATH_MSG_ERROR("Tagger Name NOT supported.");
    return Tagger::UNKNOWN;
  };

split()

std::vector< std::string > BTaggingSelectionTool::split ( const std::string & input, const char & delimiter )

private

Definition at line 841 of file BTaggingSelectionTool.cxx.

                                                                                               {
  std::vector<std::string> v;
  std::istringstream buf(input);
  for(std::string token; std::getline(buf, token, delimiter); )
    v.push_back(token);
  return v;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_acceptinfo

asg::AcceptInfo BTaggingSelectionTool::m_acceptinfo

private

Object used to store the last decision.

Definition at line 80 of file BTaggingSelectionTool.h.

m_accessor_pb

SG::AuxElement::ConstAccessor<float> BTaggingSelectionTool::m_accessor_pb

private

Definition at line 101 of file BTaggingSelectionTool.h.

m_accessor_pc

SG::AuxElement::ConstAccessor<float> BTaggingSelectionTool::m_accessor_pc

private

Definition at line 102 of file BTaggingSelectionTool.h.

m_accessor_ptau

SG::AuxElement::ConstAccessor<float> BTaggingSelectionTool::m_accessor_ptau

private

Definition at line 104 of file BTaggingSelectionTool.h.

m_accessor_pu

SG::AuxElement::ConstAccessor<float> BTaggingSelectionTool::m_accessor_pu

private

Definition at line 103 of file BTaggingSelectionTool.h.

m_continuous

bool BTaggingSelectionTool::m_continuous = false

private

Definition at line 73 of file BTaggingSelectionTool.h.

m_continuous2D

bool BTaggingSelectionTool::m_continuous2D = false

private

Definition at line 74 of file BTaggingSelectionTool.h.

m_ContinuousBenchmarks

Gaudi::Property<std::string> BTaggingSelectionTool::m_ContinuousBenchmarks {this, "CutBenchmarksContinuousWP", "", "comma separated list of tag bins that will be accepted as tagged: 1,2,3 etc.. "}

private

Definition at line 90 of file BTaggingSelectionTool.h.

{this, "CutBenchmarksContinuousWP", "", "comma separated list of tag bins that will be accepted as tagged: 1,2,3 etc.. "};

m_continuouscuts

std::vector<double> BTaggingSelectionTool::m_continuouscuts

private

Definition at line 99 of file BTaggingSelectionTool.h.

m_CutFileName

Gaudi::Property<std::string> BTaggingSelectionTool::m_CutFileName {this, "FlvTagCutDefinitionsFileName", ftag::defaults::cdi_path, "name of the files containing official cut definitions (uses PathResolver)"}

private

Definition at line 86 of file BTaggingSelectionTool.h.

{this, "FlvTagCutDefinitionsFileName", ftag::defaults::cdi_path, "name of the files containing official cut definitions (uses PathResolver)"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_ErrorOnTagWeightFailure

Gaudi::Property<bool> BTaggingSelectionTool::m_ErrorOnTagWeightFailure {this, "ErrorOnTagWeightFailure", true, "optionally ignore cases where the tagweight cannot be retrieved. default behaviour is to give an error, switching to false will turn it into a warning"}

private

Definition at line 92 of file BTaggingSelectionTool.h.

{this, "ErrorOnTagWeightFailure", true, "optionally ignore cases where the tagweight cannot be retrieved. default behaviour is to give an error, switching to false will turn it into a warning"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_inf

TFile* BTaggingSelectionTool::m_inf {}

private

Definition at line 98 of file BTaggingSelectionTool.h.

{};

m_initialised

bool BTaggingSelectionTool::m_initialised = false

private

Definition at line 72 of file BTaggingSelectionTool.h.

m_jetAuthor

Gaudi::Property<std::string> BTaggingSelectionTool::m_jetAuthor {this, "JetAuthor", ftag::defaults::jet_collection, "jet collection"}

private

Definition at line 89 of file BTaggingSelectionTool.h.

{this, "JetAuthor", ftag::defaults::jet_collection, "jet collection"};

m_maxEta

Gaudi::Property<double> BTaggingSelectionTool::m_maxEta {this, "MaxEta", 2.5, "Maximum jet eta cut"}

private

Definition at line 83 of file BTaggingSelectionTool.h.

{this, "MaxEta", 2.5, "Maximum jet eta cut"};

m_maxRangePt

Gaudi::Property<double> BTaggingSelectionTool::m_maxRangePt {this, "MaxRangePt", 3000000 , "Max pT range (in MeV)"}

private

Definition at line 84 of file BTaggingSelectionTool.h.

{this, "MaxRangePt", 3000000 /*MeV*/, "Max pT range (in MeV)"};

m_minPt

Gaudi::Property<double> BTaggingSelectionTool::m_minPt {this, "MinPt", 0 , "Minimum jet pT cut (in MeV)"}

private

Definition at line 82 of file BTaggingSelectionTool.h.

{this, "MinPt", 0 /*MeV*/, "Minimum jet pT cut (in MeV)"};

m_OP

Gaudi::Property<std::string> BTaggingSelectionTool::m_OP {this, "OperatingPoint", "", "operating point"}

private

Definition at line 88 of file BTaggingSelectionTool.h.

{this, "OperatingPoint", "", "operating point"};

m_readFromBTaggingObject

Gaudi::Property<bool> BTaggingSelectionTool::m_readFromBTaggingObject {this, "readFromBTaggingObject", false, "Enabled to access btagging scores from xAOD::BTagging object; Can be disabled for GN2v01 to access the scores from the jet itself."}

private

Definition at line 96 of file BTaggingSelectionTool.h.

{this, "readFromBTaggingObject", false,       "Enabled to access btagging scores from xAOD::BTagging object; Can be disabled for GN2v01 to access the scores from the jet itself."};

m_tagger

taggerproperties BTaggingSelectionTool::m_tagger

private

Definition at line 125 of file BTaggingSelectionTool.h.

m_taggerEnum

Tagger BTaggingSelectionTool::m_taggerEnum {UNKNOWN}

private

Definition at line 128 of file BTaggingSelectionTool.h.

{UNKNOWN};

m_taggerName

Gaudi::Property<std::string> BTaggingSelectionTool::m_taggerName {this, "TaggerName", ftag::defaults::tagger, "tagging algorithm name"}

private

Definition at line 87 of file BTaggingSelectionTool.h.

{this, "TaggerName", ftag::defaults::tagger, "tagging algorithm name"};

m_taggerWithTauFractions

bool BTaggingSelectionTool::m_taggerWithTauFractions = true

private

Definition at line 77 of file BTaggingSelectionTool.h.

m_useCTag

Gaudi::Property<bool> BTaggingSelectionTool::m_useCTag {this, "useCTagging", false, "Enabled only for FixedCut or Continuous WPs: define wether the cuts refer to b-tagging or c-tagging"}

private

Definition at line 94 of file BTaggingSelectionTool.h.

{this, "useCTagging", false, "Enabled only for FixedCut or Continuous WPs: define wether the cuts refer to b-tagging or c-tagging"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• BTaggingSelectionTool.h
• BTaggingSelectionTool.cxx