FlavorTagDiscriminants::DL2 Class Reference

#include <DL2.h>

Collaboration diagram for FlavorTagDiscriminants::DL2:

Public Member Functions
	DL2 (const lwt::GraphConfig &, const std::vector< FTagInputConfig > &, const std::vector< ConstituentsInputConfig > &={}, const FTagOptions &=FTagOptions())
void	decorate (const xAOD::BTagging &btag) const
void	decorate (const xAOD::Jet &jet) const
void	decorateWithDefaults (const SG::AuxElement &) const
void	decorate (const xAOD::Jet &jet, const SG::AuxElement &decorated) const
FTagDataDependencyNames	getDataDependencyNames () const

Private Attributes
SG::AuxElement::ConstAccessor< ElementLink< xAOD::JetContainer > >	m_jetLink
std::string	m_input_node_name
std::unique_ptr< lwt::LightweightGraph >	m_graph
std::unique_ptr< lwt::NanReplacer >	m_variable_cleaner
std::vector< internal::VarFromBTag >	m_varsFromBTag
std::vector< internal::VarFromJet >	m_varsFromJet
std::vector< std::shared_ptr< TracksLoader > >	m_tracksLoaders
std::map< std::string, internal::OutNodeFloat >	m_decorators
float	m_defaultValue
std::function< char(const internal::Tracks &)>	m_invalid_track_checker
std::vector< SG::AuxElement::Decorator< char > >	m_is_defaults
FTagDataDependencyNames	m_dataDependencyNames

Detailed Description

Definition at line 20 of file DL2.h.

Constructor & Destructor Documentation

DL2()

FlavorTagDiscriminants::DL2::DL2	(	const lwt::GraphConfig &	graph_config,
		const std::vector< FTagInputConfig > &	inputs,
		const std::vector< ConstituentsInputConfig > &	tracks_configs = {},
		const FTagOptions &	options = FTagOptions()
	)

Definition at line 22 of file DL2.cxx.

                                      :
    m_jetLink(jetLinkName),
    m_input_node_name(""),
    m_graph(new lwt::LightweightGraph(graph_config,graph_config.outputs.begin()->first)),
    m_variable_cleaner(nullptr),
    m_defaultValue(options.default_output_value)
  {
    // set up inputs
    if (graph_config.inputs.size() > 1) {
      throw std::logic_error("We don't currently support graphs with "
                             "more than one input");
    } else if (graph_config.inputs.size() == 1){
      m_input_node_name = graph_config.inputs.at(0).name;
      m_variable_cleaner.reset(new lwt::NanReplacer(
                                 graph_config.inputs.at(0).defaults,
                                 lwt::rep::all));
    }
 
    auto [vb, vj, ds] = dataprep::createBvarGetters(inputs);
    m_varsFromBTag = vb;
    m_varsFromJet = vj;
    m_dataDependencyNames += ds;
    
    for (auto config : tracks_configs){
      m_tracksLoaders.push_back(std::make_shared<TracksLoader>(config, options));
    }
 
    auto [decorators, dd, rd] = dataprep::createDecorators(
      graph_config, options);
    m_dataDependencyNames += dd;
    m_decorators = decorators;
 
    auto [track_validity, is_defaults, ipdd, rc] = dataprep::createIpChecker(
      graph_config, options);
    m_invalid_track_checker = track_validity;
    m_is_defaults = is_defaults;
    m_dataDependencyNames += ipdd;
 
    // Update dependencies and used remap from the tracks loaders.
    for (auto loader : m_tracksLoaders){
      m_dataDependencyNames += loader->getDependencies();
      rd.merge(loader->getUsedRemap());
    }
    // check that all remapping was used
    rd.merge(rc);
    dataprep::checkForUnusedRemaps(options.remap_scalar, rd);
  }

Member Function Documentation

decorate() [1/3]

void FlavorTagDiscriminants::DL2::decorate

(

const xAOD::BTagging &

btag

)

const

Definition at line 73 of file DL2.cxx.

                                                   {
    auto jetLink = m_jetLink(btag);
    if (!jetLink.isValid()) {
      throw std::runtime_error("invalid jetLink");
    }
    const xAOD::Jet& jet = **jetLink;
    decorate(jet, btag);
  }

decorate() [2/3]

void FlavorTagDiscriminants::DL2::decorate

(

const xAOD::Jet &

jet

)

const

Definition at line 81 of file DL2.cxx.

                                             {
    decorate(jet, jet);
  }

decorate() [3/3]

void FlavorTagDiscriminants::DL2::decorate	(	const xAOD::Jet &	jet,
		const SG::AuxElement &	decorated
	)		const

Definition at line 94 of file DL2.cxx.

                                                                       {
    using namespace internal;
    std::vector<NamedVar> vvec;
    for (const auto& getter: m_varsFromBTag) {
      vvec.push_back(getter(btag));
    }
    for (const auto& getter: m_varsFromJet) {
      vvec.push_back(getter(jet));
    }
    std::map<std::string, std::map<std::string, double> > nodes;
    if (m_variable_cleaner) {
      std::map<std::string, double> variables(vvec.begin(), vvec.end());
      auto cleaned = m_variable_cleaner->replace(variables);
 
      // Note, you can hack in more variables to `cleaned` here.
 
      // put the cleaned inputs into the node structure
      nodes[m_input_node_name] =  cleaned;
    }
 
    // add track sequences, check if any are invalid
    char invalid = 0;
    std::map<std::string, std::map<std::string, std::vector<double>>> seqs;
 
    for (auto loader : m_tracksLoaders){
      std::map<std::string, std::vector<double>> feats;
      std::tie(invalid, feats) = loader->getDL2Data(jet, btag, m_invalid_track_checker);
      seqs[loader->getName()] = feats;
    }
 
    for (const auto& def: m_is_defaults) {
      def(btag) = invalid;
    }
    if (invalid) {
      decorateWithDefaults(btag);
      return;
    }
 
    // save out things
    for (const auto& dec: m_decorators) {
      // the second argument to compute(...) is for sequences
      auto out_vals = m_graph->compute(nodes, seqs, dec.first);
      for (const auto& node: dec.second) {
        node.second(btag) = out_vals.at(node.first);
      }
    }
  }

decorateWithDefaults()

void FlavorTagDiscriminants::DL2::decorateWithDefaults

(

const SG::AuxElement &

jet

)

const

Definition at line 84 of file DL2.cxx.

                                                              {
    // save out things
    for (const auto& dec: m_decorators) {
      for (const auto& node: dec.second) {
        // save something that is clearly wrong
        node.second(jet) = m_defaultValue;
      }
    }
  }

getDataDependencyNames()

FTagDataDependencyNames FlavorTagDiscriminants::DL2::getDataDependencyNames

(

)

const

Definition at line 142 of file DL2.cxx.

                                                            {
    return m_dataDependencyNames;
  }

Member Data Documentation

m_dataDependencyNames

FTagDataDependencyNames FlavorTagDiscriminants::DL2::m_dataDependencyNames

private

Definition at line 47 of file DL2.h.

m_decorators

std::map<std::string, internal::OutNodeFloat> FlavorTagDiscriminants::DL2::m_decorators

private

Definition at line 42 of file DL2.h.

m_defaultValue

float FlavorTagDiscriminants::DL2::m_defaultValue

private

Definition at line 43 of file DL2.h.

m_graph

std::unique_ptr<lwt::LightweightGraph> FlavorTagDiscriminants::DL2::m_graph

private

Definition at line 37 of file DL2.h.

m_input_node_name

std::string FlavorTagDiscriminants::DL2::m_input_node_name

private

Definition at line 36 of file DL2.h.

m_invalid_track_checker

std::function<char(const internal::Tracks&)> FlavorTagDiscriminants::DL2::m_invalid_track_checker

private

Definition at line 44 of file DL2.h.

m_is_defaults

std::vector<SG::AuxElement::Decorator<char> > FlavorTagDiscriminants::DL2::m_is_defaults

private

Definition at line 45 of file DL2.h.

m_jetLink

SG::AuxElement::ConstAccessor<ElementLink<xAOD::JetContainer> > FlavorTagDiscriminants::DL2::m_jetLink

private

Definition at line 35 of file DL2.h.

m_tracksLoaders

std::vector<std::shared_ptr<TracksLoader> > FlavorTagDiscriminants::DL2::m_tracksLoaders

private

Definition at line 41 of file DL2.h.

m_variable_cleaner

std::unique_ptr<lwt::NanReplacer> FlavorTagDiscriminants::DL2::m_variable_cleaner

private

Definition at line 38 of file DL2.h.

m_varsFromBTag

std::vector<internal::VarFromBTag> FlavorTagDiscriminants::DL2::m_varsFromBTag

private

Definition at line 39 of file DL2.h.

m_varsFromJet

std::vector<internal::VarFromJet> FlavorTagDiscriminants::DL2::m_varsFromJet

private

Definition at line 40 of file DL2.h.

---

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

• DL2.h
• DL2.cxx