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	ElectronsLoader
class	FlowElementsLoader
class	FoldDecoratorAlg
struct	FTagDataDependencyNames
class	FTagGhostElectronAssociationAlg
	an algorithm for adding ghost electrons to jets More...
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	HitDecoratorAlg
class	HitsLoader
class	IConstituentsLoader
class	INNSharingSvc
struct	InputVariableConfig
class	JetHitAssociationAlg
class	JetTagConditionalDecoratorAlg
class	JetTagDecoratorAlg
class	LinkCounterAlg
class	MultifoldGNN
class	MultifoldGNNTool
class	NNSharingSvc
class	PoorMansIpAugmenterAlg
class	SaltModelOutput
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::FLOW_ELEMENT, ConstituentsType::TRACK, ConstituentsType::HIT, ConstituentsType::ELECTRON }
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	SaltModelVersion { SaltModelVersion::UNKNOWN, SaltModelVersion::V0, SaltModelVersion::V1, SaltModelVersion::V2 }

Functions
TrackLinkType	trackLinkTypeFromString (const std::string &)
ConstituentsInputConfig	createConstituentsLoaderConfig (const std::string &name, const std::vector< std::string > &input_variables, FlipTagConfig flip_config)
ConstituentsInputConfig	createElectronsLoaderConfig (std::pair< std::string, std::vector< std::string >> iparticle_names)
FlipTagConfig	flipTagConfigFromString (const std::string &)
void	propify (asg::AsgTool &tool, GNNToolProperties *props)
GNNOptions	getOptions (const GNNToolProperties &)
HbbGraphConfig	getHbbGraphConfig (const lwt::GraphConfig &cfg)
ConstituentsInputConfig	createHitsLoaderConfig (std::pair< std::string, std::vector< std::string >> hits_names)
	NLOHMANN_JSON_SERIALIZE_ENUM (SaltModelVersion, { { SaltModelVersion::UNKNOWN, "" }, { SaltModelVersion::V0, "v0" }, { SaltModelVersion::V1, "v1" }, { SaltModelVersion::V2, "v2" }, }) class SaltModel 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/SaltModel.h.

Tracks

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

Definition at line 36 of file PhysicsAnalysis/JetTagging/FlavorTagDiscriminants/FlavorTagDiscriminants/TracksLoader.h.

Enumeration Type Documentation

ConstituentsEDMType

enum FlavorTagDiscriminants::ConstituentsEDMType

strong

Enumerator
CHAR
UCHAR
INT
FLOAT
DOUBLE
CUSTOM_GETTER

Definition at line 31 of file PhysicsAnalysis/JetTagging/FlavorTagDiscriminants/FlavorTagDiscriminants/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 PhysicsAnalysis/JetTagging/FlavorTagDiscriminants/FlavorTagDiscriminants/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 PhysicsAnalysis/JetTagging/FlavorTagDiscriminants/FlavorTagDiscriminants/ConstituentsLoader.h.

                                     {
        ABS_D0_SIGNIFICANCE_DESCENDING,
        D0_SIGNIFICANCE_DESCENDING,
        PT_DESCENDING,
        ABS_D0_DESCENDING
    };

ConstituentsType

enum FlavorTagDiscriminants::ConstituentsType

strong

Enumerator
FLOW_ELEMENT
TRACK
HIT
ELECTRON

Definition at line 48 of file PhysicsAnalysis/JetTagging/FlavorTagDiscriminants/FlavorTagDiscriminants/ConstituentsLoader.h.

                                {
        FLOW_ELEMENT,
        TRACK,
        HIT,
        ELECTRON
    };

EDMType

enum FlavorTagDiscriminants::EDMType

strong

Enumerator
CHAR
UCHAR
INT
FLOAT
DOUBLE
CUSTOM_GETTER

Definition at line 33 of file PhysicsAnalysis/JetTagging/FlavorTagDiscriminants/FlavorTagDiscriminants/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
  };

SaltModelVersion

enum FlavorTagDiscriminants::SaltModelVersion

strong

Enumerator
UNKNOWN
V0
V1
V2

Definition at line 30 of file FlavorTagDiscriminants/FlavorTagDiscriminants/SaltModel.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 123 of file PhysicsAnalysis/JetTagging/FlavorTagDiscriminants/Root/ConstituentsLoader.cxx.

     {
      ConstituentsInputConfig config;
      TypeRegexes electron_type_regexes {
          // default electron variables
          {"(deltaEta1|deltaPhiRescaled2|"
               "ftag_energyOverP|Rhad|Rhad1|"
               "Eratio|weta2|Rphi|Reta|wtots1|f1|f3|pt|eta|phi)"_r, ConstituentsEDMType::FLOAT},
          // custom variables
          {"(ftag_.*|ptfrac|ptrel|dr)"_r, ConstituentsEDMType::CUSTOM_GETTER},
          // variables extracted from the corresponding track
          {"(numberOf.*|d0.*|abs_eta|qOverP|eProbabilityHT)"_r, ConstituentsEDMType::CUSTOM_GETTER}
      };
      TypeRegexes hits_type_regexes {
          // hits variables
          // ConstituentsEDMType picked correspond to the first matching regex
          {"(j|a|b)"_r, ConstituentsEDMType::CUSTOM_GETTER}
      };
      TypeRegexes flow_type_regexes {
          // FlowElement variables
          // ConstituentsEDMType picked correspond to the first matching regex
          {"(pt|deta|dphi|dr|energy|isCharged)"_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|muon_quality)"_r, ConstituentsEDMType::CHAR},
          {"(pT_wrtJet|pZ_wrtJet|EFrac_wrtJet).*"_r, ConstituentsEDMType::CUSTOM_GETTER},
          {"muon_(qOverPratio|momentumBalanceSignificance|scatteringNeighbourSignificance)"_r, ConstituentsEDMType::FLOAT},
          {"lifetimeSigned.*"_r, ConstituentsEDMType::CUSTOM_GETTER}
      };
      // 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},
      };
 
      // For now we have only one selection for electrons
      SelRegexes electron_select_regexes {
        {".*_r22default.*"_r, ConstituentsSelection::R22_DEFAULT}
      };
      
      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_flow_input_config(
          name, input_variables,
          flow_type_regexes);
        config.type = ConstituentsType::FLOW_ELEMENT;
        config.output_name = "flows";
      }
      else if (name.find("hits") != std::string::npos){
        config = get_hits_input_config(
          name, input_variables,
          hits_type_regexes);
        config.type = ConstituentsType::HIT;
        config.output_name = "hits";
      }
      else if (name.find("electrons") != std::string::npos){
        config = get_electron_input_config(
          name, input_variables,
          electron_type_regexes,
          electron_select_regexes);
        config.type = ConstituentsType::ELECTRON;
        config.output_name = "electrons";
      }
      else{
        throw std::runtime_error(
          "Unknown constituent type: " + name + ". Only tracks, flows, hits and electrons are supported."
          );
      }
      return config;
    }

createElectronsLoaderConfig()

ConstituentsInputConfig FlavorTagDiscriminants::createElectronsLoaderConfig

(

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

iparticle_names

)

createHitsLoaderConfig()

ConstituentsInputConfig FlavorTagDiscriminants::createHitsLoaderConfig

(

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

hits_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 24 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;
    {
      const auto& d = props.default_output_values;
      opts.default_output_values.insert(d.begin(), d.end());
    }
    opts.default_zero_tracks = props.default_zero_tracks;
    return opts;
  }

negativeIpOnly()

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

Definition at line 218 of file PhysicsAnalysis/JetTagging/FlavorTagDiscriminants/Root/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 ( SaltModelVersion  , { { SaltModelVersion::UNKNOWN, "" }, { SaltModelVersion::V0, "v0" }, { SaltModelVersion::V1, "v1" }, { SaltModelVersion::V2, "v2" }, }    )

final

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

                                                   {
    { SaltModelVersion::UNKNOWN, "" },
    { SaltModelVersion::V0, "v0" },
    { SaltModelVersion::V1, "v1" },
    { SaltModelVersion::V2, "v2" },
  })
 
  //
  // Utility class that loads the onnx model from the given path
  // and runs inference based on the user given inputs
 
  class SaltModel final{
 
    public:
      using OutputConfig = std::vector<SaltModelOutput>;
 
      SaltModel(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;
      SaltModelVersion getSaltModelVersion() 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;
 
      SaltModelVersion m_onnx_model_version = SaltModelVersion::UNKNOWN;
 
  }; // Class SaltModel

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);
    t.declareProperty("defaultOutputValues", props->default_output_values);
    t.declareProperty("defaultZeroTracks", props->default_zero_tracks);
  }

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