#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. More...

StatusCode	initialize () override
	Dummy implementation of the initialisation function. More...

virtual asg::AcceptData	accept (const xAOD::IParticle *p) const override
	Get the decision using a generic IParticle pointer. More...

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. More...

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. More...

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. More...

virtual void	print () const
	Print the state of the tool. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

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

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Private Types
enum	Tagger { UNKNOWN, DL1, GN1, GN2, MV2c10 }

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. More...

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> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
bool	m_initialised = false

bool	m_ErrorOnTagWeightFailure = true

bool	m_continuous = false

bool	m_continuous2D = false

bool	m_useCTag = false

bool	m_readFromBTaggingObject = true

asg::AcceptInfo	m_acceptinfo
	Object used to store the last decision. More...

double	m_maxEta {}

double	m_minPt {}

double	m_maxRangePt {}

std::string	m_CutFileName

std::string	m_taggerName

std::string	m_OP

std::string	m_jetAuthor

std::string	m_ContinuousBenchmarks

std::string	m_wps_raw

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) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 24 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 27 of file BTaggingSelectionTool.h.

Member Enumeration Documentation

◆ Tagger

enum BTaggingSelectionTool::Tagger

private

Enumerator
UNKNOWN
DL1
GN1
GN2
MV2c10

Definition at line 119 of file BTaggingSelectionTool.h.

119 {UNKNOWN, DL1, GN1, GN2, MV2c10};

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" )
 {
   namespace def = ftag::defaults;
   m_initialised = false;
   declareProperty( "MaxEta", m_maxEta = 2.5 );
   declareProperty( "MinPt", m_minPt = 0 /*MeV*/);
   declareProperty( "MaxRangePt", m_maxRangePt = 3000000 /*MeV*/);
   declareProperty( "FlvTagCutDefinitionsFileName", m_CutFileName=def::cdi_path, "name of the files containing official cut definitions (uses PathResolver)");
   declareProperty( "TaggerName",                    m_taggerName=def::tagger,    "tagging algorithm name");
   declareProperty( "OperatingPoint",                m_OP="",            "operating point");
   declareProperty( "JetAuthor",                     m_jetAuthor=def::jet_collection,     "jet collection");
   declareProperty( "WorkingPointDefinitions",       m_wps_raw="FixedCutBEff_85,FixedCutBEff_77,FixedCutBEff_70,FixedCutBEff_60",       "Comma-separated list of tagger working points (in decreasing order of efficiency!) - required for 1D tagging purposes");
   declareProperty( "ErrorOnTagWeightFailure",       m_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");
   declareProperty( "CutBenchmarksContinuousWP",     m_ContinuousBenchmarks="", "comma separated list of tag bins that will be accepted as tagged: 1,2,3 etc.. ");
   declareProperty( "useCTagging",                   m_useCTag=false, "Enabled only for FixedCut or Continuous WPs: define wether the cuts refer to b-tagging or c-tagging");
   declareProperty( "readFromBTaggingObject",        m_readFromBTaggingObject=false,       "Enabled to access btagging scores from xAOD::BTagging object; Can be disabled for GN2v01 to access the scores from the jet itself.");
 }

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 IAsgSelectionTool.

Definition at line 433 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 452 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 481 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 533 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 572 of file BTaggingSelectionTool.cxx.

 {
   if (m_tagger.name == "GN2v01"){
     asg::AcceptData acceptData (&m_acceptinfo);
     ATH_MSG_ERROR("For GN2v01 tagger, there is a new tau claass 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 583 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 758 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() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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());
  
   }

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

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.

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ ExtractTaggerProperties()

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

private

Definition at line 225 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::DL1) || (m_taggerEnum == Tagger::GN1) || (m_taggerEnum == Tagger::GN2)){
  
     TString fraction_data_name = taggerName+"/"+m_jetAuthor+"/"+OP+"/fraction";
     TVector *fraction_data = dynamic_cast<TVector*> (m_inf->Get(fraction_data_name));
     
     double fraction = -1;
     if(fraction_data!=nullptr){
       fraction = fraction_data[0](0);
     }else{
       if("DL1"    ==taggerName){ fraction = 0.08; }
       if("DL1mu"  ==taggerName){ fraction = 0.08; }
       if("DL1rnn" ==taggerName){ fraction = 0.03; }
     }
     tagger.fraction_c = fraction;
     tagger.fraction_b = fraction;
  
     double fraction_tau = 0.;
     double fraction_tau_cTag = 0.;
     TString fraction_tau_name = taggerName+"/"+m_jetAuthor+"/"+OP+"/fraction_tau";
     TVector *fraction_tau_data = dynamic_cast<TVector*> (m_inf->Get(fraction_tau_name));
     if (m_taggerEnum == Tagger::GN2 && !(taggerName.find("GN2v00") != std::string::npos)){
       if( fraction_tau_data != nullptr ) {
         if (m_useCTag){
           // tau fraction for c-tagging 
           fraction_tau_cTag = fraction_tau_data[0](0);
         }
         else{
           // tau fraction for b-tagging 
           fraction_tau = fraction_tau_data[0](0);
         }
       }
       else {
         // For GN2v01 taggers and onwards the fraction_tau should be in the CDI file 
         ATH_MSG_ERROR("Tagger fraction_tau is not available");
         return StatusCode::FAILURE;
       }
     }
     tagger.fraction_tau = fraction_tau;
     tagger.fraction_tau_cTag = fraction_tau_cTag;
  
     delete fraction_data;
     delete fraction_tau_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 63 of file BTaggingSelectionTool.h.

63 {return m_acceptinfo;}

◆ getCutValue()

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

overridevirtual

Implements IBTaggingSelectionTool.

Definition at line 776 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::TEvent 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::TEvent, 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::TEvent 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::TEvent, 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 624 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 644 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 673 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 714 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 299 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 303 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_taggerName == "GN2v01")
       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 372 of file BTaggingSelectionTool.cxx.

                                                                                                                {
   if (m_tagger.name == "GN2v01"){
     ATH_MSG_ERROR("For GN2v01 tagger, there is a new tau claass 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 381 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 385 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::DL1) || (m_taggerEnum == Tagger::GN1) || (m_taggerEnum == Tagger::GN2)){
  
     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 ( )

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 62 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 tagging cut definitions" );
     return StatusCode::FAILURE;
   }
  
   // check the CDI file for the selected tagger and jet collection
   TString check_CDI = m_taggerName;
   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);
  
  // 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;
  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*:
    if ( m_taggerName == "GN2v01" ){
      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;
       // For GN2v01, we have different WPs than the default ones.
       if ( m_taggerName == "GN2v01" )
         m_wps_raw="FixedCutBEff_90,FixedCutBEff_85,FixedCutBEff_77,FixedCutBEff_70,FixedCutBEff_65";
       std::vector<std::string> workingpoints = split(m_wps_raw, ',');
       std::sort(workingpoints.begin(), workingpoints.end());
       std::reverse(workingpoints.begin(), workingpoints.end()); // put in descending order
       for(const std::string& wp : workingpoints){
         cutname = m_taggerName + "/" + m_jetAuthor + "/" + 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 {  // FixedCut Working Point: load only one WP
     if(m_useCTag){
       ATH_MSG_WARNING( "Running in FixedCut WP and using c-tagging");
     }
     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() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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 JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, LundVariablesTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, 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 122 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 == "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 807 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ 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 77 of file BTaggingSelectionTool.h.

◆ m_accessor_pb

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

private

Definition at line 93 of file BTaggingSelectionTool.h.

◆ m_accessor_pc

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

private

Definition at line 94 of file BTaggingSelectionTool.h.

◆ m_accessor_ptau

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

private

Definition at line 96 of file BTaggingSelectionTool.h.

◆ m_accessor_pu

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

private

Definition at line 95 of file BTaggingSelectionTool.h.

◆ m_continuous

bool BTaggingSelectionTool::m_continuous = false

private

Definition at line 72 of file BTaggingSelectionTool.h.

◆ m_continuous2D

bool BTaggingSelectionTool::m_continuous2D = false

private

Definition at line 73 of file BTaggingSelectionTool.h.

◆ m_ContinuousBenchmarks

std::string BTaggingSelectionTool::m_ContinuousBenchmarks

private

Definition at line 87 of file BTaggingSelectionTool.h.

◆ m_continuouscuts

std::vector<double> BTaggingSelectionTool::m_continuouscuts

private

Definition at line 91 of file BTaggingSelectionTool.h.

◆ m_CutFileName

std::string BTaggingSelectionTool::m_CutFileName

private

Definition at line 83 of file BTaggingSelectionTool.h.

◆ 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

bool BTaggingSelectionTool::m_ErrorOnTagWeightFailure = true

private

Definition at line 71 of file BTaggingSelectionTool.h.

◆ 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 90 of file BTaggingSelectionTool.h.

◆ m_initialised

bool BTaggingSelectionTool::m_initialised = false

private

Definition at line 70 of file BTaggingSelectionTool.h.

◆ m_jetAuthor

std::string BTaggingSelectionTool::m_jetAuthor

private

Definition at line 86 of file BTaggingSelectionTool.h.

◆ m_maxEta

double BTaggingSelectionTool::m_maxEta {}

private

Definition at line 79 of file BTaggingSelectionTool.h.

◆ m_maxRangePt

double BTaggingSelectionTool::m_maxRangePt {}

private

Definition at line 81 of file BTaggingSelectionTool.h.

◆ m_minPt

double BTaggingSelectionTool::m_minPt {}

private

Definition at line 80 of file BTaggingSelectionTool.h.

◆ m_OP

std::string BTaggingSelectionTool::m_OP

private

Definition at line 85 of file BTaggingSelectionTool.h.

◆ m_readFromBTaggingObject

bool BTaggingSelectionTool::m_readFromBTaggingObject = true

private

Definition at line 75 of file BTaggingSelectionTool.h.

◆ m_tagger

taggerproperties BTaggingSelectionTool::m_tagger

private

Definition at line 117 of file BTaggingSelectionTool.h.

◆ m_taggerEnum

Tagger BTaggingSelectionTool::m_taggerEnum {UNKNOWN}

private

Definition at line 120 of file BTaggingSelectionTool.h.

◆ m_taggerName

std::string BTaggingSelectionTool::m_taggerName

private

Definition at line 84 of file BTaggingSelectionTool.h.

◆ m_useCTag

bool BTaggingSelectionTool::m_useCTag = false

private

Definition at line 74 of file BTaggingSelectionTool.h.

◆ 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.

◆ m_wps_raw

std::string BTaggingSelectionTool::m_wps_raw

private

Definition at line 88 of file BTaggingSelectionTool.h.

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

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

◆ tagWeight_member_t

Member Enumeration Documentation

◆ Tagger

Constructor & Destructor Documentation

◆ BTaggingSelectionTool()

Member Function Documentation

◆ accept() [1/6]

◆ accept() [2/6]

◆ accept() [3/6]

◆ accept() [4/6]

◆ accept() [5/6]

◆ accept() [6/6]

◆ checkRange()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ ExtractTaggerProperties()

◆ extraDeps_update_handler()

◆ getAcceptInfo()

◆ getCutValue()

◆ getKey()

◆ getName()

◆ getProperty()

◆ getQuantile() [1/4]

◆ getQuantile() [2/4]

◆ getQuantile() [3/4]

◆ getQuantile() [4/4]

◆ getTaggerWeight() [1/5]

◆ getTaggerWeight() [2/5]

◆ getTaggerWeight() [3/5]

◆ getTaggerWeight() [4/5]

◆ getTaggerWeight() [5/5]

◆ initialize()

◆ InitializeTaggerVariables()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msg_level_name()

◆ msgLvl()

◆ outputHandles()

◆ print()

◆ renounce()

◆ renounceArray()

◆ SetTaggerEnum()

◆ split()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_acceptinfo

◆ m_accessor_pb

◆ m_accessor_pc

◆ m_accessor_ptau

◆ m_accessor_pu

◆ m_continuous

◆ m_continuous2D

◆ m_ContinuousBenchmarks

◆ m_continuouscuts

◆ m_CutFileName

◆ m_detStore

◆ m_ErrorOnTagWeightFailure