#include <MV2Tag.h>

Inheritance diagram for Analysis::MV2Tag:

Collaboration diagram for Analysis::MV2Tag:

Public Member Functions
	MV2Tag (const std::string &name, const std::string &n, const IInterface *)

virtual	~MV2Tag ()=default
	Implementations of the methods defined in the abstract base class. More...

virtual StatusCode	initialize () override

virtual void	assignProbability (xAOD::BTagging *BTag, const std::map< std::string, double > &inputs, const std::string &jetauthor) const override

Private Member Functions
float	d0sgn_wrtJet (const TLorentzVector &jet, const TLorentzVector &trk, float d0sig) const

float	z0sgn_wrtJet (float trackTheta, float trackZ0, float jetEta) const

std::vector< float >	CreateVariables (const std::map< std::string, double > &inputs, const std::vector< std::string > &inputVars) const

std::vector< float >	GetMulticlassResponse (const std::vector< float > &vars, const MVAUtils::BDT *bdt) const

double	GetClassResponse (const std::vector< float > &vars, const MVAUtils::BDT *bdt) const

Private Attributes
std::string	m_taggerNameBase

std::string	m_varStrName

SG::ReadCondHandleKey< JetTagCalibCondData >	m_readKey {this, "HistosKey", "JetTagCalibHistosKey", "Key of input (derived) JetTag calibration data"}
	Key of calibration data: More...

bool	m_forceMV2CalibrationAlias

std::string	m_MV2CalibAlias

std::string	m_xAODBaseName

std::map< std::string, double >	m_defaultvals

std::map< std::string, std::string >	m_MVTM_name_translations
	Map from names in tool input to names in calibration file. More...

std::map< std::string, std::string >	m_MVTM_name_backtrans
	Map from names in calibration file to names in tool input. More...

const unsigned	m_nClasses =3

std::atomic< bool >	m_disableAlgo

std::atomic< int >	m_warnCounter

std::string	m_runModus
	This switch is needed to indicate what to do. More...

Detailed Description

BDT-based tagger combining more than 20 upper stream b-tagging variables

Author: K.Mochizuki, L.Vacavant, M.Ughetto modified May 2016 J. Shlomi

Definition at line 31 of file MV2Tag.h.

Constructor & Destructor Documentation

◆ MV2Tag()

Analysis::MV2Tag::MV2Tag	(	const std::string &	name,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 34 of file MV2Tag.cxx.

                                                                               :
     base_class(name, n,p),
     m_runModus("analysis") {
  
     // force MV2 to always use a calibration derived from MV2CalibAlias jet collection
     declareProperty("forceMV2CalibrationAlias", m_forceMV2CalibrationAlias = true);
     declareProperty("MV2CalibAlias", m_MV2CalibAlias = "AntiKt4EMTopo");
  
     // global configuration:
     declareProperty("Runmodus", m_runModus);
  
     declareProperty("xAODBaseName",      m_xAODBaseName);//"MV2c20" or etc.
  
     // which calibration folder to use
     declareProperty("taggerNameBase", m_taggerNameBase = "MV2");
  
     declareProperty("defaultvals", m_defaultvals );
     declareProperty("MVTMvariableNames", m_MVTM_name_translations );
  
  
   }

◆ ~MV2Tag()

virtual Analysis::MV2Tag::~MV2Tag ( )

virtualdefault

Implementations of the methods defined in the abstract base class.

Member Function Documentation

◆ assignProbability()

void Analysis::MV2Tag::assignProbability	(	xAOD::BTagging *	BTag,
		const std::map< std::string, double > &	inputs,
		const std::string &	jetauthor
	)		const

overridevirtual

give information to the info class.

Definition at line 75 of file MV2Tag.cxx.

   {
      /*
      * #index for this function
      * #1: Preparation of MVA instance using MVAUtils BDT
      * #2: set input variables from MultivariateTagManager inputs map
      * #3: Calcuation of MVA output variable(s)
      * #4: Fill MVA output variable(s) into xAOD
      */
  
     // #0: Check if disabled or not
     if ( m_disableAlgo ) {
       if (m_warnCounter<20) {
         ATH_MSG_WARNING("#BTAG# .... algorithm was disabled due to mis-configuration problems: no output will be written ... PLEASE WATCH OUT" );
         m_warnCounter++;
       }
     }
  
     // #1: Preparation of MVA instance using egammaBDT
     /* jet author: */
     std::string author(assigned_jet_author);
     ATH_MSG_DEBUG("#BTAG# Jet author for MV2: " << author);
  
     if (m_forceMV2CalibrationAlias) {
       author = m_MV2CalibAlias;
     }
  
     //Retrieval of Calibration Condition Data objects
     SG::ReadCondHandle<JetTagCalibCondData> readCdo(m_readKey);
  
     std::string alias = readCdo->getChannelAlias(author);
  
     //Retrieve BDT from cond object
     MVAUtils::BDT *bdt(nullptr);
     ATH_MSG_DEBUG("#BTAG# Getting MVAUtils::BDT for "<<m_taggerNameBase);
     bdt = readCdo->retrieveBdt(m_taggerNameBase,author);
     if (!bdt) {
       ATH_MSG_WARNING("#BTAG# No BDT for " << m_taggerNameBase<<" exists in the condition object.. Disabling algorithm.");
       m_disableAlgo=true;
       return;
     }
  
     //Retrieve input variables of BDT from cond object
     std::vector<std::string> inputVars = readCdo->retrieveInputVars(m_taggerNameBase,author, m_taggerNameBase+"Calib/"+m_varStrName);
     std::vector<float> vars = CreateVariables (inputs, inputVars);
     ATH_MSG_DEBUG("#BTAG# nConfigVar"<<vars.size());
  
     if ( inputVars.size()!=vars.size() ) {
       ATH_MSG_WARNING("#BTAG# Number of expected variables for MVA: "<< vars.size() << "  does not match the number of variables found in the calibration file: " << inputVars.size() << " ... the algorithm will be 'disabled' "<<alias<<" "<<author);
       m_disableAlgo=true;
       return;
     }
  
  
     // #3: Calculation of MVA output variable(s)
     /* compute MV2: */
     double mv2 = -10.;  double mv2m_pb=-10., mv2m_pu=-10., mv2m_pc=-10.;
  
     if (m_taggerNameBase.find("MV2c")!=std::string::npos) mv2= GetClassResponse(vars, bdt);//this gives back double
       else { //if it is MV2m
         std::vector<float> outputs= GetMulticlassResponse(vars, bdt);//this gives back float
         //vector size is checked in the function above
         mv2m_pb=outputs[0]; mv2m_pu=outputs[1]; mv2m_pc=outputs[2] ;
       }
  
     if (m_taggerNameBase.find("MV2c")!=std::string::npos) ATH_MSG_DEBUG("#BTAG# MV2 weight: " << mv2<<", "<<alias<<", "<<author);
     else ATH_MSG_DEBUG("#BTAG# MV2 pb, pu, pc= " << mv2m_pb<<"\t"<<mv2m_pu<<"\t"<<mv2m_pc<<", "<<alias<<", "<<author);
  
     // #4: Fill MVA output variable(s) into xAOD
     if(m_runModus=="analysis") {
  
       if (m_taggerNameBase.find("MV2c")!=std::string::npos) {
         //MV2cXX
         BTag->setVariable<float>(m_xAODBaseName, "discriminant", mv2);
       }else {
         //MV2m
         BTag->setVariable<float>(m_xAODBaseName, "pb", mv2m_pb);
         BTag->setVariable<float>(m_xAODBaseName, "pu", mv2m_pu);
         BTag->setVariable<float>(m_xAODBaseName, "pc", mv2m_pc);
       }
     }
  
   }//end assign probability

◆ CreateVariables()

std::vector< float > Analysis::MV2Tag::CreateVariables	(	const std::map< std::string, double > &	inputs,
		const std::vector< std::string > &	inputVars
	)		const

private

Definition at line 181 of file MV2Tag.cxx.

   {
     std::vector<float> vals;
     vals.reserve (inputVars.size());
  
     for (const std::string& varName : inputVars) {
       std::string inputName = varName;
       auto it = m_MVTM_name_backtrans.find (varName);
       if (it != m_MVTM_name_backtrans.end()) inputName = it->second;
       auto it2 = inputs.find (inputName);
       if (it2 == inputs.end()) {
       }
       else {
         double val = it2->second;
         if (std::isnan (val)) {
           val = m_defaultvals.at (varName);
         }
         vals.push_back (val);
       }
     }
     return vals;
   }

◆ d0sgn_wrtJet()

float Analysis::MV2Tag::d0sgn_wrtJet	(	const TLorentzVector &	jet,
		const TLorentzVector &	trk,
		float	d0sig
	)		const

private

Definition at line 162 of file MV2Tag.cxx.

                                                                                                     {
     const double dPhi = jet.DeltaPhi(trk);
     const float d0_sign = sin(dPhi) * d0sig;
  
     if (std::fabs(d0_sign) < 1e-4)
       return 1.0;
  
     const float res = d0_sign / std::fabs(d0_sign);
     return res;
   }

◆ GetClassResponse()

double Analysis::MV2Tag::GetClassResponse	(	const std::vector< float > &	vars,
		const MVAUtils::BDT *	bdt
	)		const

inlineprivate

Definition at line 97 of file MV2Tag.h.

◆ GetMulticlassResponse()

std::vector<float> Analysis::MV2Tag::GetMulticlassResponse	(	const std::vector< float > &	vars,
		const MVAUtils::BDT *	bdt
	)		const

inlineprivate

Definition at line 91 of file MV2Tag.h.

◆ initialize()

StatusCode Analysis::MV2Tag::initialize ( )

overridevirtual

Definition at line 57 of file MV2Tag.cxx.

                                 {
  
     m_disableAlgo=false;
     m_warnCounter=0;
  
     m_varStrName = "variables";
  
     // prepare readKey for calibration data:
     ATH_CHECK(m_readKey.initialize());
  
     for (const auto& p : m_MVTM_name_translations) {
       m_MVTM_name_backtrans[p.second] = p.first;
     }
  
     return StatusCode::SUCCESS;
   }

◆ z0sgn_wrtJet()

float Analysis::MV2Tag::z0sgn_wrtJet	(	float	trackTheta,
		float	trackZ0,
		float	jetEta
	)		const

private

Definition at line 173 of file MV2Tag.cxx.

                                                                                 {
     const float trackEta = -std::log(std::tan(trackTheta/2.));
     const float zs = (jetEta - trackEta)*trackZ0;
     return (zs>=0. ? 1. : -1.);
   }

Member Data Documentation

◆ m_defaultvals

std::map<std::string, double > Analysis::MV2Tag::m_defaultvals

private

Definition at line 66 of file MV2Tag.h.

◆ m_disableAlgo

std::atomic<bool> Analysis::MV2Tag::m_disableAlgo

mutableprivate

Definition at line 75 of file MV2Tag.h.

◆ m_forceMV2CalibrationAlias

bool Analysis::MV2Tag::m_forceMV2CalibrationAlias

private

Definition at line 62 of file MV2Tag.h.

◆ m_MV2CalibAlias

std::string Analysis::MV2Tag::m_MV2CalibAlias

private

Definition at line 63 of file MV2Tag.h.

◆ m_MVTM_name_backtrans

std::map<std::string, std::string > Analysis::MV2Tag::m_MVTM_name_backtrans

private

Map from names in calibration file to names in tool input.

Definition at line 70 of file MV2Tag.h.

◆ m_MVTM_name_translations

std::map<std::string, std::string > Analysis::MV2Tag::m_MVTM_name_translations

private

Map from names in tool input to names in calibration file.

Definition at line 68 of file MV2Tag.h.

◆ m_nClasses

const unsigned Analysis::MV2Tag::m_nClasses =3

private

Definition at line 73 of file MV2Tag.h.

◆ m_readKey

SG::ReadCondHandleKey<JetTagCalibCondData> Analysis::MV2Tag::m_readKey {this, "HistosKey", "JetTagCalibHistosKey", "Key of input (derived) JetTag calibration data"}

private

Key of calibration data:

Definition at line 61 of file MV2Tag.h.

◆ m_runModus

std::string Analysis::MV2Tag::m_runModus

private

This switch is needed to indicate what to do.

The algorithm can be run to produce reference histograms from the given MC files (m_runModus=0) or to work in analysis mode (m_runModus=1) where already made reference histograms are read. 0=Do not read histos, 1=Read referece histos (analysis mode)

Definition at line 81 of file MV2Tag.h.

◆ m_taggerNameBase

std::string Analysis::MV2Tag::m_taggerNameBase

private

Definition at line 57 of file MV2Tag.h.

◆ m_varStrName

std::string Analysis::MV2Tag::m_varStrName

private

Definition at line 58 of file MV2Tag.h.

◆ m_warnCounter

std::atomic<int> Analysis::MV2Tag::m_warnCounter

mutableprivate

Definition at line 76 of file MV2Tag.h.

◆ m_xAODBaseName

std::string Analysis::MV2Tag::m_xAODBaseName

private

Definition at line 64 of file MV2Tag.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MV2Tag()

◆ ~MV2Tag()

Member Function Documentation

◆ assignProbability()

◆ CreateVariables()

◆ d0sgn_wrtJet()

◆ GetClassResponse()

◆ GetMulticlassResponse()

◆ initialize()

◆ z0sgn_wrtJet()

Member Data Documentation

◆ m_defaultvals

◆ m_disableAlgo

◆ m_forceMV2CalibrationAlias

◆ m_MV2CalibAlias

◆ m_MVTM_name_backtrans

◆ m_MVTM_name_translations

◆ m_nClasses

◆ m_readKey

◆ m_runModus

◆ m_taggerNameBase

◆ m_varStrName

◆ m_warnCounter

◆ m_xAODBaseName