AsgElectronSelectorTool::SelectionLayer Struct Reference

Collaboration diagram for AsgElectronSelectorTool::SelectionLayer:

Public Member Functions
bool	initialize (TEnv &env, const std::string &prefixName, const std::string &layerName, const std::string &m_modelFileName, const std::string &m_quantileFileName, asg::AsgTool *parentTool)
std::vector< float >	evaluate (const std::vector< double > &inputs) const

Public Attributes
std::string	name
std::string	prefix
std::unique_ptr< const ElectronDNNCalculator >	m_mvaTool
	Pointer to the class that calculates the MVA score.
std::vector< std::string >	m_variables
	Variables used in the MVA Tool.
std::vector< int >	m_enum_variables
	Enum version of used variables.
unsigned int	m_nOutputs
bool	m_multiClass {}
	Multiclass model or not.
bool	m_CFReject {}
	Run CF rejection or not.
bool	m_cfSignal {}
	Use the CF output node in the numerator or the denominator.
std::vector< double >	m_fractions
	Fractions to combine the output nodes of a multiclass model into one discriminant.
std::vector< int >	m_cutAmbiguity
	do cut on ambiguity bit
std::vector< int >	m_cutBL
	cut min on b-layer hits
std::vector< int >	m_cutPi
	cut min on pixel hits
std::vector< int >	m_cutSCT
	cut min on precision hits
std::vector< double >	m_cutSelector
	cut on mva output
std::vector< double >	m_cutSelectorCF
std::vector< float >	m_defaultOutputs
	Default vector to return if calculation fails.

Detailed Description

Definition at line 137 of file AsgElectronSelectorTool.h.

Member Function Documentation

evaluate()

std::vector< float > AsgElectronSelectorTool::SelectionLayer::evaluate

(

const std::vector< double > &

inputs

)

const

Definition at line 199 of file AsgElectronSelectorTool.cxx.

                                                                                                      {
    if (!m_mvaTool) return m_defaultOutputs;
    auto scores = m_mvaTool->calculate(inputs);
    std::vector<float> res(scores.rows());
    for (int i = 0; i < scores.rows(); ++i) {
        res[i] = scores(i, 0);
    }
    return res;
}

initialize()

bool AsgElectronSelectorTool::SelectionLayer::initialize	(	TEnv &	env,
		const std::string &	prefixName,
		const std::string &	layerName,
		const std::string &	m_modelFileName,
		const std::string &	m_quantileFileName,
		asg::AsgTool *	parentTool )

Definition at line 89 of file AsgElectronSelectorTool.cxx.

  {
    prefix = prefixName;
    name = layerName;
    unsigned int numberOfExpectedBinCombinedMVA = AsgElectronSelectorTool::s_fnDiscEtBins * AsgElectronSelectorTool::s_fnDiscEtaBins;
    unsigned int numberOfExpectedEtaBins = AsgElectronSelectorTool::s_fnDiscEtBins;
    // 1. Getting quantiles and model files 
    std::string modelFile = !userModelFileName.empty()
        ? userModelFileName
        : env.GetValue((prefix + "inputModelFileName").c_str(), "");
 
    std::string quantileFile = !userQuantileFileName.empty()
        ? userQuantileFileName
        : env.GetValue((prefix + "inputQuantileFileName").c_str(), "");
 
    std::string modelPath = PathResolverFindCalibFile(modelFile);
    std::string quantilePath = PathResolverFindCalibFile(quantileFile);
 
    if (modelPath.empty() || quantilePath.empty()) {
        return false;
    }
 
    // 2. 
    m_multiClass = env.GetValue((prefix + "multiClass").c_str(), false);
    m_nOutputs = env.GetValue((prefix + "n_outputs").c_str(), m_multiClass ? 6 : 1);
    // Include cf node in numerator or denominator when combining different outputs
    m_cfSignal = env.GetValue((prefix + "cfSignal").c_str(), false);
 
    // 3. 
    std::string varStr = env.GetValue((prefix + "Variables").c_str(), "");
    std::stringstream varsStream(varStr);
    std::string substr;
 
    std::vector<std::string> tempVariables;
    m_enum_variables.clear();
 
    while (std::getline(varsStream, substr, ',')) {
        if (substr.empty()) continue;
        if (!prefix.empty() && substr.rfind(prefix, 0) == 0) {
            substr = substr.substr(prefix.length());
        }
        if (!AllowedVariables::variableMap.contains(substr)) {
            return false;
        }
        tempVariables.push_back(substr);
        m_enum_variables.push_back(AllowedVariables::variableMap.at(substr));
    }
 
    if (tempVariables.empty()) return false;
 
    m_cutAmbiguity = AsgConfigHelper::HelperInt((prefix + "CutAmbiguity").c_str(), env);
    m_cutBL        = AsgConfigHelper::HelperInt((prefix + "CutBL").c_str(), env);
    m_cutPi        = AsgConfigHelper::HelperInt((prefix + "CutPi").c_str(), env);
    m_cutSCT       = AsgConfigHelper::HelperInt((prefix + "CutSCT").c_str(), env);
    m_fractions    = AsgConfigHelper::HelperDouble((prefix + "Fractions").c_str(), env);
    m_cutSelector  = AsgConfigHelper::HelperDouble((prefix + "CutSelector").c_str(), env);
    m_cutSelectorCF = AsgConfigHelper::HelperDouble((prefix + "CutSelectorCF").c_str(), env);
    
 
 
    if (m_cutSelector.size() != numberOfExpectedBinCombinedMVA){
      parentTool->msg(MSG::ERROR) <<"Configuration issue :  cutSelector expected size " << numberOfExpectedBinCombinedMVA <<
                    " input size " << m_cutSelector.size();
      return false;
    }
    if (!m_cutSelectorCF.empty()){
      m_CFReject = true;
      if (m_cutSelectorCF.size() != numberOfExpectedBinCombinedMVA){
        parentTool->msg(MSG::ERROR) <<"Configuration issue :  cutSelectorCF expected size " << numberOfExpectedBinCombinedMVA <<
                      " input size " << m_cutSelectorCF.size();
        return false;
      }
      if(!m_multiClass){
        parentTool->msg(MSG::ERROR) <<"Configuration issue :  CF rejection is only defined "
                      "for multiClass: TRUE";
        return false;
      }
      } else {
      m_CFReject = false;
      }
 
    if (m_multiClass){
      unsigned int nFractionsPerBin = m_nOutputs - 1;
      unsigned int expectedFractionsSize = numberOfExpectedEtaBins * nFractionsPerBin;
 
      if (m_fractions.size() != expectedFractionsSize) {
          parentTool->msg(MSG::ERROR) <<"Configuration issue: multiclass is TRUE, but the number of fractions (" 
                        << m_fractions.size() << ") does not match " << m_nOutputs << " classes (" 
                        << expectedFractionsSize << " fractions expected).";
          return false;
      }
    }
      
    m_mvaTool = std::make_unique<ElectronDNNCalculator>(
        dynamic_cast<AsgElectronSelectorTool*>(parentTool),
        modelPath.c_str(),
        quantilePath.c_str(),
        tempVariables
    );
 
    m_defaultOutputs = std::vector<float>(m_nOutputs, -999.0f);
    return true;
}

Member Data Documentation

m_CFReject

bool AsgElectronSelectorTool::SelectionLayer::m_CFReject {}

Run CF rejection or not.

Definition at line 155 of file AsgElectronSelectorTool.h.

{};

m_cfSignal

bool AsgElectronSelectorTool::SelectionLayer::m_cfSignal {}

Use the CF output node in the numerator or the denominator.

Definition at line 157 of file AsgElectronSelectorTool.h.

{};

m_cutAmbiguity

std::vector<int> AsgElectronSelectorTool::SelectionLayer::m_cutAmbiguity

do cut on ambiguity bit

Definition at line 161 of file AsgElectronSelectorTool.h.

m_cutBL

std::vector<int> AsgElectronSelectorTool::SelectionLayer::m_cutBL

cut min on b-layer hits

Definition at line 163 of file AsgElectronSelectorTool.h.

m_cutPi

std::vector<int> AsgElectronSelectorTool::SelectionLayer::m_cutPi

cut min on pixel hits

Definition at line 165 of file AsgElectronSelectorTool.h.

m_cutSCT

std::vector<int> AsgElectronSelectorTool::SelectionLayer::m_cutSCT

cut min on precision hits

Definition at line 167 of file AsgElectronSelectorTool.h.

m_cutSelector

std::vector<double> AsgElectronSelectorTool::SelectionLayer::m_cutSelector

cut on mva output

Definition at line 169 of file AsgElectronSelectorTool.h.

m_cutSelectorCF

std::vector<double> AsgElectronSelectorTool::SelectionLayer::m_cutSelectorCF

Definition at line 170 of file AsgElectronSelectorTool.h.

m_defaultOutputs

std::vector<float> AsgElectronSelectorTool::SelectionLayer::m_defaultOutputs

Default vector to return if calculation fails.

Definition at line 172 of file AsgElectronSelectorTool.h.

m_enum_variables

std::vector<int> AsgElectronSelectorTool::SelectionLayer::m_enum_variables

Enum version of used variables.

Definition at line 148 of file AsgElectronSelectorTool.h.

m_fractions

std::vector<double> AsgElectronSelectorTool::SelectionLayer::m_fractions

Fractions to combine the output nodes of a multiclass model into one discriminant.

Definition at line 159 of file AsgElectronSelectorTool.h.

m_multiClass

bool AsgElectronSelectorTool::SelectionLayer::m_multiClass {}

Multiclass model or not.

Definition at line 153 of file AsgElectronSelectorTool.h.

{};

m_mvaTool

std::unique_ptr<const ElectronDNNCalculator> AsgElectronSelectorTool::SelectionLayer::m_mvaTool

Pointer to the class that calculates the MVA score.

const for thread safety

Definition at line 142 of file AsgElectronSelectorTool.h.

m_nOutputs

unsigned int AsgElectronSelectorTool::SelectionLayer::m_nOutputs

Definition at line 150 of file AsgElectronSelectorTool.h.

m_variables

std::vector<std::string> AsgElectronSelectorTool::SelectionLayer::m_variables

Variables used in the MVA Tool.

Definition at line 145 of file AsgElectronSelectorTool.h.

name

std::string AsgElectronSelectorTool::SelectionLayer::name

Definition at line 138 of file AsgElectronSelectorTool.h.

prefix

std::string AsgElectronSelectorTool::SelectionLayer::prefix

Definition at line 139 of file AsgElectronSelectorTool.h.

---

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

• AsgElectronSelectorTool.h
• AsgElectronSelectorTool.cxx