FlavorTagDiscriminants Namespace Reference

This file contains "getter" functions used for accessing tagger inputs from the EDM. More...

Namespaces
	dataprep
	defaults
	detail
	getter_utils
	hbb_key
	internal
	str
	TruthDecoratorHelpers

Classes
class	BacklinkAlg
class	BTagAugmenterTool
class	BTagConditionalDecoratorAlg
class	BTagDecoratorAlg
class	BTaggingBuilderAlg
class	BTagMuonAugmenter
class	BTagMuonAugmenterTool
class	BTagTrackLinkCopyAlg
class	CAccDec
struct	ConstituentsInputConfig
class	CountIParticleAlg
class	CountTrackParticleAlg
class	DecoratorAlg
class	DL2
class	DL2HighLevel
struct	DL2Properties
class	DL2Tool
class	FoldDecoratorAlg
struct	FTagDataDependencyNames
struct	FTagInputConfig
struct	FTagOptions
class	GNN
class	GNNAuxTaskDecoratorAlg
struct	GNNOptions
class	GNNTool
struct	GNNToolProperties
struct	HbbGraphConfig
class	HbbTag
struct	HbbTagConfig
struct	HbbTagProperties
class	HbbTagTool
class	IConstituentsLoader
class	INNSharingSvc
struct	InputVariableConfig
class	IParticlesLoader
class	JetTagConditionalDecoratorAlg
class	JetTagDecoratorAlg
class	LinkCounterAlg
class	MultifoldGNN
class	MultifoldGNNTool
class	NNSharingSvc
class	OnnxOutput
class	PoorMansIpAugmenterAlg
class	SoftElectronDecoratorAlg
class	SoftElectronTruthDecoratorAlg
class	TrackClassifier
class	TrackLeptonDecoratorAlg
class	TracksLoader
class	TrackTruthDecoratorAlg
class	TruthParticleDecoratorAlg
class	VRJetOverlapDecoratorTool

Typedefs
typedef SG::AuxElement	AE
using	Inputs = std::pair< std::vector< float >, std::vector< int64_t > >
using	Tracks = std::vector< const xAOD::TrackParticle * >

Enumerations
enum	TrackLinkType { TrackLinkType::TRACK_PARTICLE, TrackLinkType::IPARTICLE }
enum	ConstituentsEDMType {   ConstituentsEDMType::CHAR, ConstituentsEDMType::UCHAR, ConstituentsEDMType::INT, ConstituentsEDMType::FLOAT,   ConstituentsEDMType::DOUBLE, ConstituentsEDMType::CUSTOM_GETTER }
enum	ConstituentsSortOrder { ConstituentsSortOrder::ABS_D0_SIGNIFICANCE_DESCENDING, ConstituentsSortOrder::D0_SIGNIFICANCE_DESCENDING, ConstituentsSortOrder::PT_DESCENDING, ConstituentsSortOrder::ABS_D0_DESCENDING }
enum	ConstituentsSelection {   ConstituentsSelection::ALL, ConstituentsSelection::IP3D_2018, ConstituentsSelection::DIPS_TIGHT_UPGRADE, ConstituentsSelection::DIPS_LOOSE_UPGRADE,   ConstituentsSelection::DIPS_LOOSE_202102, ConstituentsSelection::LOOSE_202102_NOIP, ConstituentsSelection::R22_DEFAULT, ConstituentsSelection::R22_LOOSE }
enum	ConstituentsType { ConstituentsType::IPARTICLE, ConstituentsType::TRACK }
enum	EDMType {   EDMType::CHAR, EDMType::UCHAR, EDMType::INT, EDMType::FLOAT,   EDMType::DOUBLE, EDMType::CUSTOM_GETTER }
enum	FlipTagConfig { FlipTagConfig::STANDARD, FlipTagConfig::NEGATIVE_IP_ONLY, FlipTagConfig::FLIP_SIGN, FlipTagConfig::SIMPLE_FLIP }
enum	OnnxModelVersion { OnnxModelVersion::UNKNOWN, OnnxModelVersion::V0, OnnxModelVersion::V1, OnnxModelVersion::V2 }

Functions
TrackLinkType	trackLinkTypeFromString (const std::string &)
ConstituentsInputConfig	createConstituentsLoaderConfig (const std::string &name, const std::vector< std::string > &input_variables, FlipTagConfig flip_config)
FlipTagConfig	flipTagConfigFromString (const std::string &)
void	propify (asg::AsgTool &tool, GNNToolProperties *props)
GNNOptions	getOptions (const GNNToolProperties &)
HbbGraphConfig	getHbbGraphConfig (const lwt::GraphConfig &cfg)
ConstituentsInputConfig	createIParticlesLoaderConfig (std::pair< std::string, std::vector< std::string >> iparticle_names)
	NLOHMANN_JSON_SERIALIZE_ENUM (OnnxModelVersion, { { OnnxModelVersion::UNKNOWN, "" }, { OnnxModelVersion::V0, "v0" }, { OnnxModelVersion::V1, "v1" }, { OnnxModelVersion::V2, "v2" }, }) class OnnxUtil final
ConstituentsInputConfig	createTracksLoaderConfig (std::pair< std::string, std::vector< std::string >> trk_names, FlipTagConfig flip_config)
Tracks	negativeIpOnly (BTagTrackIpAccessor &aug, const Tracks &tracks, const xAOD::Jet &j)
template<typename T >
std::size_t	getHash (const T &obj)
size_t	combine (size_t lhs, size_t rhs)

Detailed Description

This file contains "getter" functions used for accessing tagger inputs from the EDM.

In the most basic case, inputs can be directly retrieved from the EDM using accessors. In other cases, inputs require custom code called "custom getters" to produce the desired values.

• a basic "getter" directly retrieves decorated values from an object
• a "custom getter" executes custom code to produce inputs (e.g. particle.pt()). Custom getters are used for inputs that cannot be directly retrieved from the EDM using accessors or which require on-the-fly calculations, such as IP variables.
• a "sequence getter" is a wrapper around a getter that broadcasts it over a vector of associated objects (for example over all the tracks in a jet).

Inputs to tagging algorithms are configured when the algorithm is initialised which means that the list of track and jet features that are used as inputs is not known at compile time. Instead we build an array of "getter" functions, each of which returns one feature for the tagger.

NOTE: This file is for experts only, don't expect support.

Typedef Documentation

AE

typedef SG::AuxElement FlavorTagDiscriminants::AE

Definition at line 36 of file BTagMuonAugmenter.h.

Inputs

using FlavorTagDiscriminants::Inputs = typedef std::pair<std::vector<float>, std::vector<int64_t> >

Definition at line 28 of file FlavorTagDiscriminants/FlavorTagDiscriminants/OnnxUtil.h.

Tracks

using FlavorTagDiscriminants::Tracks = typedef std::vector<const xAOD::TrackParticle*>

Definition at line 36 of file TracksLoader.h.

Enumeration Type Documentation

ConstituentsEDMType

enum FlavorTagDiscriminants::ConstituentsEDMType

strong

Enumerator
CHAR
UCHAR
INT
FLOAT
DOUBLE
CUSTOM_GETTER

Definition at line 31 of file ConstituentsLoader.h.

{CHAR, UCHAR, INT, FLOAT, DOUBLE, CUSTOM_GETTER};

ConstituentsSelection

enum FlavorTagDiscriminants::ConstituentsSelection

strong

Enumerator
ALL
IP3D_2018
DIPS_TIGHT_UPGRADE
DIPS_LOOSE_UPGRADE
DIPS_LOOSE_202102
LOOSE_202102_NOIP
R22_DEFAULT
R22_LOOSE

Definition at line 38 of file ConstituentsLoader.h.

                                     {
        ALL,
        IP3D_2018,
        DIPS_TIGHT_UPGRADE,
        DIPS_LOOSE_UPGRADE,
        DIPS_LOOSE_202102,
        LOOSE_202102_NOIP,
        R22_DEFAULT,
        R22_LOOSE
    };

ConstituentsSortOrder

enum FlavorTagDiscriminants::ConstituentsSortOrder

strong

Enumerator
ABS_D0_SIGNIFICANCE_DESCENDING
D0_SIGNIFICANCE_DESCENDING
PT_DESCENDING
ABS_D0_DESCENDING

Definition at line 32 of file ConstituentsLoader.h.

                                     {
        ABS_D0_SIGNIFICANCE_DESCENDING,
        D0_SIGNIFICANCE_DESCENDING,
        PT_DESCENDING,
        ABS_D0_DESCENDING
    };

ConstituentsType

enum FlavorTagDiscriminants::ConstituentsType

strong

Enumerator
IPARTICLE
TRACK

Definition at line 48 of file ConstituentsLoader.h.

                                {
        IPARTICLE,
        TRACK
    };

EDMType

enum FlavorTagDiscriminants::EDMType

strong

Enumerator
CHAR
UCHAR
INT
FLOAT
DOUBLE
CUSTOM_GETTER

Definition at line 33 of file DataPrepUtilities.h.

{CHAR, UCHAR, INT, FLOAT, DOUBLE, CUSTOM_GETTER};

FlipTagConfig

enum FlavorTagDiscriminants::FlipTagConfig

strong

Enumerator
STANDARD
NEGATIVE_IP_ONLY
FLIP_SIGN
SIMPLE_FLIP

Definition at line 14 of file FlipTagEnums.h.

                           {
    STANDARD,                   // use all tracks
    NEGATIVE_IP_ONLY,           // use only negative IP, flip sign
    FLIP_SIGN,                  // just flip the sign of IP3D_signed_d0_significance, IP3D_signed_z0_significance, use all tracks
    SIMPLE_FLIP,                // flip the sign of d0, z0SinTheta, IP3D_signed_d0_significance, IP3D_signed_z0_significance, use all tracks
  };

OnnxModelVersion

enum FlavorTagDiscriminants::OnnxModelVersion

strong

Enumerator
UNKNOWN
V0
V1
V2

Definition at line 30 of file FlavorTagDiscriminants/FlavorTagDiscriminants/OnnxUtil.h.

{UNKNOWN, V0, V1, V2};

TrackLinkType

enum FlavorTagDiscriminants::TrackLinkType

strong

Enumerator
TRACK_PARTICLE
IPARTICLE

Definition at line 12 of file AssociationEnums.h.

                           {
    TRACK_PARTICLE,
    IPARTICLE
  };

Function Documentation

combine()

size_t FlavorTagDiscriminants::combine ( size_t  lhs, size_t  rhs  )

inline

Definition at line 21 of file hash.h.

                                                  {
    lhs ^= rhs + 0x517cc1b727220a95 + (lhs << 6) + (lhs >> 2);
    return lhs;
  }

createConstituentsLoaderConfig()

ConstituentsInputConfig FlavorTagDiscriminants::createConstituentsLoaderConfig	(	const std::string &	name,
		const std::vector< std::string > &	input_variables,
		FlipTagConfig	flip_config
	)

Definition at line 84 of file ConstituentsLoader.cxx.

     {
      ConstituentsInputConfig config;
 
      TypeRegexes iparticle_type_regexes {
          // iparticle variables
          // ConstituentsEDMType picked correspond to the first matching regex
          {"(pt|deta|dphi|energy)"_r, ConstituentsEDMType::CUSTOM_GETTER}
      };
      TypeRegexes trk_type_regexes {
          // Some innermost / next-to-innermost hit variables had a different
          // definition in 21p9, recomputed here with customGetter to reuse
          // existing training
          // ConstituentsEDMType picked correspond to the first matching regex
          {"numberOf.*21p9"_r, ConstituentsEDMType::CUSTOM_GETTER},
          {"numberOf.*"_r, ConstituentsEDMType::UCHAR},
          {"btagIp_(d0|z0SinTheta)Uncertainty"_r, ConstituentsEDMType::FLOAT},
          {"(numberDoF|chiSquared|qOverP|theta)"_r, ConstituentsEDMType::FLOAT},
          {"(^.*[_])?(d|z)0.*"_r, ConstituentsEDMType::CUSTOM_GETTER},
          {"(log_)?(ptfrac|dr|pt).*"_r, ConstituentsEDMType::CUSTOM_GETTER},
          {"(deta|dphi)"_r, ConstituentsEDMType::CUSTOM_GETTER},
          {"phi|theta|qOverP"_r, ConstituentsEDMType::FLOAT},
          {"(phi|theta|qOverP)Uncertainty"_r, ConstituentsEDMType::CUSTOM_GETTER},
          {"leptonID"_r, ConstituentsEDMType::CHAR}
      };
      // We have a number of special naming conventions to sort and
      // filter tracks. The track nodes should be named according to
      //
      // tracks_<selection>_<sort-order>
      //
      SortRegexes trk_sort_regexes {
          {".*absSd0sort"_r, ConstituentsSortOrder::ABS_D0_SIGNIFICANCE_DESCENDING},
          {".*sd0sort"_r, ConstituentsSortOrder::D0_SIGNIFICANCE_DESCENDING},
          {".*ptsort"_r, ConstituentsSortOrder::PT_DESCENDING},
          {".*absD0DescendingSort"_r, ConstituentsSortOrder::ABS_D0_DESCENDING},
      };
      SelRegexes trk_select_regexes {
          {".*_ip3d_.*"_r, ConstituentsSelection::IP3D_2018},
          {".*_dipsTightUpgrade_.*"_r, ConstituentsSelection::DIPS_TIGHT_UPGRADE},
          {".*_dipsLooseUpgrade_.*"_r, ConstituentsSelection::DIPS_LOOSE_UPGRADE},
          {".*_all_.*"_r, ConstituentsSelection::ALL},
          {".*_dipsLoose202102_.*"_r, ConstituentsSelection::DIPS_LOOSE_202102},
          {".*_loose202102NoIpCuts_.*"_r, ConstituentsSelection::LOOSE_202102_NOIP},
          {".*_r22default_.*"_r, ConstituentsSelection::R22_DEFAULT},
          {".*_r22loose_.*"_r, ConstituentsSelection::R22_LOOSE},
      };
      
      if (name.find("tracks") != std::string::npos){
        std::regex flip_sequences;
        if (flip_config == FlipTagConfig::FLIP_SIGN || flip_config == FlipTagConfig::NEGATIVE_IP_ONLY){
          flip_sequences=std::regex(".*signed_[dz]0.*");
        }
        if (flip_config == FlipTagConfig::SIMPLE_FLIP){
          flip_sequences=std::regex("(.*signed_[dz]0.*)|d0|z0SinTheta");
        }
        config = get_track_input_config(
          name, input_variables,
          trk_type_regexes, trk_sort_regexes, trk_select_regexes,
          flip_sequences, flip_config);
        config.type = ConstituentsType::TRACK;
        config.output_name = "tracks";
      }
      else if (name.find("flows") != std::string::npos){
        config = get_iparticle_input_config(
          name, input_variables,
          iparticle_type_regexes);
        config.type = ConstituentsType::IPARTICLE;
        config.output_name = "flows";
      }
      else{
        throw std::runtime_error(
          "Unknown constituent type: " + name + ". Only tracks and flows are supported."
          );
      }
      return config;
    }

createIParticlesLoaderConfig()

ConstituentsInputConfig FlavorTagDiscriminants::createIParticlesLoaderConfig

(

std::pair< std::string, std::vector< std::string >>

iparticle_names

)

createTracksLoaderConfig()

ConstituentsInputConfig FlavorTagDiscriminants::createTracksLoaderConfig	(	std::pair< std::string, std::vector< std::string >>	trk_names,
		FlipTagConfig	flip_config
	)

flipTagConfigFromString()

FlipTagConfig FlavorTagDiscriminants::flipTagConfigFromString

(

const std::string &

name

)

Definition at line 15 of file FlipTagEnums.cxx.

                                                               {
    RETURN_CONFIG(STANDARD);
    RETURN_CONFIG(NEGATIVE_IP_ONLY);
    RETURN_CONFIG(FLIP_SIGN);
    RETURN_CONFIG(SIMPLE_FLIP);
    throw std::logic_error("b-tagging flip config '" + name + "' unknown");
  }

getHash()

template<typename T >

std::size_t FlavorTagDiscriminants::getHash

(

const T &

obj

)

Definition at line 13 of file hash.h.

                                  {
    return std::hash<T>{}(obj);
  }

getHbbGraphConfig()

HbbGraphConfig FlavorTagDiscriminants::getHbbGraphConfig

(

const lwt::GraphConfig &

cfg

)

Definition at line 29 of file HbbGraphConfig.cxx.

                                                                   {
    namespace hk = FlavorTagDiscriminants::hbb_key;
    HbbGraphConfig k;
    k.n_subjets = 0;
    std::regex subjet_match(hk::subjet + "[0-9]+");
    std::string first_match;
    for (const auto& node: graph_cfg.inputs) {
      for (const auto& var: node.variables) {
        const std::string& name = var.name;
        k.defaults[node.name][name] = node.defaults.at(name);
      }
      if (node.name == hk::fatjet) {
        for (const auto& var: node.variables) {
          k.fatjet.insert(var.name);
        }
      } else if (std::regex_match(node.name, subjet_match)) {
        std::set<std::string> subjet_set;
        for (const auto& var: node.variables) {
          subjet_set.insert(var.name);
        }
        if (k.n_subjets == 0) {
          k.subjet = subjet_set;
          first_match = node.name;
        } else if (k.subjet != subjet_set) {
          std::string error = "mismatch in subjet keys: we expect the same"
            " variables to be read from each subjet. ";
          error.append("first subjet (" + first_match + ") "
                       + formatSet(k.subjet) + ", match "
                       + std::to_string(k.n_subjets)
                       + ", (" + node.name + ") " + formatSet(subjet_set));
          throw std::runtime_error(error);
        }
        k.n_subjets++;
      } else {
        throw std::runtime_error("no way to match '" + node.name + "'");
      }
    }
    return k;
  }

getOptions()

GNNOptions FlavorTagDiscriminants::getOptions

(

const GNNToolProperties &

props

)

Definition at line 22 of file GNNToolifiers.cxx.

                                                        {
    GNNOptions opts;
    if (props.flipTagConfig.size() > 0) {
      opts.flip_config = flipTagConfigFromString(props.flipTagConfig);
    }
    opts.variable_remapping = props.variableRemapping;
    if (props.trackLinkType.size() > 0) {
      opts.track_link_type = trackLinkTypeFromString(props.trackLinkType);
    }
    opts.default_output_value = props.default_output_value;
    return opts;
  }

negativeIpOnly()

Tracks FlavorTagDiscriminants::negativeIpOnly	(	BTagTrackIpAccessor &	aug,
		const Tracks &	tracks,
		const xAOD::Jet &	j
	)

Definition at line 214 of file TracksLoader.cxx.

    {
        Tracks filtered;
        // we want to reverse the order of the tracks as part of the
        // flipping
        for (auto ti = tracks.crbegin(); ti != tracks.crend(); ti++) {
          const xAOD::TrackParticle* tp = *ti;
          double sip = aug.getSignedIp(*tp, j).ip3d_signed_d0_significance;
          if (sip < 0) filtered.push_back(tp);
        }
        return filtered;
      }

NLOHMANN_JSON_SERIALIZE_ENUM()

FlavorTagDiscriminants::NLOHMANN_JSON_SERIALIZE_ENUM ( OnnxModelVersion  , { { OnnxModelVersion::UNKNOWN, "" }, { OnnxModelVersion::V0, "v0" }, { OnnxModelVersion::V1, "v1" }, { OnnxModelVersion::V2, "v2" }, }    )

final

Definition at line 32 of file FlavorTagDiscriminants/FlavorTagDiscriminants/OnnxUtil.h.

                                                   {
    { OnnxModelVersion::UNKNOWN, "" },
    { OnnxModelVersion::V0, "v0" },
    { OnnxModelVersion::V1, "v1" },
    { OnnxModelVersion::V2, "v2" },
  })
 
  //
  // Utility class that loads the onnx model from the given path
  // and runs inference based on the user given inputs
 
  class OnnxUtil final{
 
    public:
      using OutputConfig = std::vector<OnnxOutput>;
 
      OnnxUtil(const std::string& path_to_onnx);
 
      void initialize();
 
      struct InferenceOutput {
        std::map<std::string, float> singleFloat;
        std::map<std::string, std::vector<char>> vecChar;
        std::map<std::string, std::vector<float>> vecFloat;
      };
 
      InferenceOutput runInference(std::map<std::string, Inputs>& gnn_inputs) const;
 
      const lwt::GraphConfig getLwtConfig() const;
      const nlohmann::json& getMetadata() const;
      const OutputConfig& getOutputConfig() const;
      OnnxModelVersion getOnnxModelVersion() const;
      const std::string& getModelName() const;
 
    private:
      const nlohmann::json loadMetadata(const std::string& key) const;
      const std::string determineModelName() const;
 
      nlohmann::json m_metadata;
      std::string m_path_to_onnx;
 
      std::unique_ptr< Ort::Session > m_session;
      std::unique_ptr< Ort::Env > m_env;
 
      size_t m_num_inputs;
      size_t m_num_outputs;
      std::string m_model_name;
      std::vector<std::string> m_input_node_names;
      OutputConfig m_output_nodes;
 
      OnnxModelVersion m_onnx_model_version = OnnxModelVersion::UNKNOWN;
 
  }; // Class OnnxUtil

propify()

void FlavorTagDiscriminants::propify	(	asg::AsgTool &	tool,
		GNNToolProperties *	props
	)

Definition at line 12 of file GNNToolifiers.cxx.

                                                        {
    t.declareProperty("flipTagConfig", props->flipTagConfig,
      "flip configuration used for calibration");
    t.declareProperty("variableRemapping", props->variableRemapping,
      "user-defined mapping to rename the vars stored in the NN");
    t.declareProperty("trackLinkType", props->trackLinkType,
      "access tracks as IParticleContainer or as TrackParticleContainer");
    t.declareProperty("defaultOutputValue", props->default_output_value);
  }

trackLinkTypeFromString()

TrackLinkType FlavorTagDiscriminants::trackLinkTypeFromString

(

const std::string &

name

)

Definition at line 15 of file AssociationEnums.cxx.

                                                               {
    RETURN_CONFIG(TRACK_PARTICLE);
    RETURN_CONFIG(IPARTICLE);
    throw std::logic_error("DL2 association scheme '" + name + "' unknown");
  }