FlavorTagDiscriminants::dataprep Namespace Reference

Typedefs
typedef std::vector< std::pair< std::regex, std::string > >	StringRegexes

Functions
StringRegexes	getNameFlippers (const FlipTagConfig &flip_config)
std::tuple< std::vector< FTagInputConfig >, std::vector< ConstituentsInputConfig >, FTagOptions >	createGetterConfig (lwt::GraphConfig &graph_config, FlipTagConfig flip_config, std::map< std::string, std::string > remap_scalar, TrackLinkType track_link_type)
std::tuple< std::vector< internal::VarFromBTag >, std::vector< internal::VarFromJet >, FTagDataDependencyNames >	createBvarGetters (const std::vector< FTagInputConfig > &inputs)
std::tuple< std::map< std::string, internal::OutNodeFloat >, FTagDataDependencyNames, std::set< std::string > >	createDecorators (const lwt::GraphConfig &config, const FTagOptions &options)
std::tuple< std::function< char(const internal::Tracks &)>, std::vector< SG::AuxElement::Decorator< char > >, FTagDataDependencyNames, std::set< std::string > >	createIpChecker (const lwt::GraphConfig &, const FTagOptions &)
void	checkForUnusedRemaps (const std::map< std::string, std::string > &requested, const std::set< std::string > &used)

Typedef Documentation

StringRegexes

typedef std::vector<std::pair<std::regex, std::string> > FlavorTagDiscriminants::dataprep::StringRegexes

Definition at line 148 of file DataPrepUtilities.h.

Function Documentation

checkForUnusedRemaps()

void FlavorTagDiscriminants::dataprep::checkForUnusedRemaps	(	const std::map< std::string, std::string > &	requested,
		const std::set< std::string > &	used
	)

Definition at line 454 of file DataPrepUtilities.cxx.

    {
      // we want to make sure every remapping was used
      std::set<std::string> unused;
      for (auto [k, v]: requested) {
        if (!used.count(k)) unused.insert(k);
      }
      if (unused.size() > 0) {
        std::string outputs;
        for (const auto& item: unused) {
          outputs.append(item);
          if (item != *unused.rbegin()) outputs.append(", ");
        }
        throw std::logic_error("found unused output remapping(s): " + outputs);
      }
    }

createBvarGetters()

std::tuple< std::vector< internal::VarFromBTag >, std::vector< internal::VarFromJet >, FTagDataDependencyNames > FlavorTagDiscriminants::dataprep::createBvarGetters

(

const std::vector< FTagInputConfig > &

inputs

)

Definition at line 349 of file DataPrepUtilities.cxx.

    {
      FTagDataDependencyNames deps;
      std::vector<internal::VarFromBTag> varsFromBTag;
      std::vector<internal::VarFromJet> varsFromJet;
 
      for (const auto& input: inputs) {
        if (input.type != EDMType::CUSTOM_GETTER) {
          auto filler = internal::get::varFromBTag(input.name, input.type,
                                         input.default_flag);
          deps.bTagInputs.insert(input.name);
          varsFromBTag.push_back(filler);
        } else {
          varsFromJet.push_back(getter_utils::namedCustomJetGetter(input.name));
        }
        if (input.default_flag.size() > 0) {
          deps.bTagInputs.insert(input.default_flag);
        }
      }
 
      return std::make_tuple(varsFromBTag, varsFromJet, deps);
    }

createDecorators()

std::tuple< std::map< std::string, internal::OutNodeFloat >, FTagDataDependencyNames, std::set< std::string > > FlavorTagDiscriminants::dataprep::createDecorators	(	const lwt::GraphConfig &	config,
		const FTagOptions &	options
	)

Definition at line 382 of file DataPrepUtilities.cxx.

    {
      FTagDataDependencyNames deps;
      std::map<std::string, internal::OutNodeFloat> decorators;
      std::map<std::string, std::string> remap = options.remap_scalar;
      std::set<std::string> used_remap;
 
      for (const auto& out_node: config.outputs) {
        std::string node_name = out_node.first;
 
        internal::OutNodeFloat node;
        for (const std::string& element: out_node.second.labels) {
          std::string name = node_name + "_" + element;
 
          // let user rename the output
          if (auto h = remap.extract(name)){
            name = h.mapped();
            used_remap.insert(h.key());
          }
          deps.bTagOutputs.insert(name);
 
          SG::AuxElement::Decorator<float> f(name);
          node.emplace_back(element, f);
        }
        decorators[node_name] = node;
      }
 
      return std::make_tuple(decorators, deps, used_remap);
    }

createGetterConfig()

std::tuple< std::vector< FTagInputConfig >, std::vector< ConstituentsInputConfig >, FTagOptions > FlavorTagDiscriminants::dataprep::createGetterConfig	(	lwt::GraphConfig &	graph_config,
		FlipTagConfig	flip_config,
		std::map< std::string, std::string >	remap_scalar,
		TrackLinkType	track_link_type
	)

Definition at line 235 of file DataPrepUtilities.cxx.

     {
 
      // we rewrite the inputs if we're using flip taggers
      StringRegexes flip_converters = getNameFlippers(flip_config);
 
      if (flip_config != FlipTagConfig::STANDARD) {
        rewriteFlipConfig(config, flip_converters);
      }
 
      // build the jet inputs
 
      // type and default value-finding regexes are hardcoded for now
      TypeRegexes type_regexes = {
        {".*_isDefaults"_r, EDMType::CHAR},
        // TODO: in the future we should migrate RNN and IPxD
        // variables to floats. This is outside the scope of the
        // current flavor tagging developments and AFT-438.
        {"IP[23]D(Neg)?_[pbc](b|c|u|tau)"_r, EDMType::FLOAT},
        {"SV1(Flip)?_[pbc](b|c|u|tau)"_r, EDMType::FLOAT},
        {"(rnnip|iprnn|(?:dips|DIPS)[^_]*)(flip)?_p(b|c|u|tau)"_r, EDMType::FLOAT},
        {"(JetFitter|SV1|JetFitterSecondaryVertex)(Flip)?_[Nn].*"_r, EDMType::INT},
        {"(JetFitter|SV1|JetFitterSecondaryVertex).*"_r, EDMType::FLOAT},
        {"(log_)?pt|abs_eta|eta|phi|energy|mass"_r, EDMType::CUSTOM_GETTER},
        {"softMuon_p[bcu]"_r, EDMType::FLOAT},
        {"softMuon_.*"_r, EDMType::FLOAT},
      };
 
      StringRegexes default_flag_regexes{
        {"IP2D_.*"_r, "IP2D_isDefaults"},
        {"IP2DNeg_.*"_r, "IP2DNeg_isDefaults"},
        {"IP3D_.*"_r, "IP3D_isDefaults"},
        {"IP3DNeg_.*"_r, "IP3DNeg_isDefaults"},
        {"SV1_.*"_r, "SV1_isDefaults"},
        {"SV1Flip_.*"_r, "SV1Flip_isDefaults"},
        {"JetFitter_.*"_r, "JetFitter_isDefaults"},
        {"JetFitterFlip_.*"_r, "JetFitterFlip_isDefaults"},
        {"JetFitterSecondaryVertex_.*"_r, "JetFitterSecondaryVertex_isDefaults"},
        {"JetFitterSecondaryVertexFlip_.*"_r, "JetFitterSecondaryVertexFlip_isDefaults"},
        {"rnnip_.*"_r, "rnnip_isDefaults"},
        {"((?:dips|DIPS)[^_]*)_.*"_r, "$1_isDefaults"},
        {"rnnipflip_.*"_r, "rnnipflip_isDefaults"},
        {"iprnn_.*"_r, ""},
        {"smt_.*"_r, "softMuon_isDefaults"},
        {"softMuon_.*"_r, "softMuon_isDefaults"},
        {"((log_)?pt|abs_eta|eta|phi|energy|mass)"_r, ""}}; // no default for custom cases
 
      std::vector<FTagInputConfig> input_config;
      for (auto& node: config.inputs){
        // allow the user to remape some of the inputs
        remap_inputs(node.variables, remap_scalar, node.defaults);
 
        std::vector<std::string> input_names;
        for (const auto& var: node.variables) {
          input_names.push_back(var.name);
        }
 
        // check to make sure the next line doesn't overwrite something
        // TODO: figure out how to support multiple scalar input nodes
        if (!input_config.empty()) {
          throw std::logic_error(
            "We don't currently support multiple scalar input nodes");
        }
        input_config = get_input_config(input_names, type_regexes, default_flag_regexes);
      }
 
      // build the constituents inputs
      std::vector<std::pair<std::string, std::vector<std::string>>> constituent_names;
      for (auto& node: config.input_sequences) {
        remap_inputs(node.variables, remap_scalar,
             node.defaults);
 
        std::vector<std::string> names;
        for (const auto& var: node.variables) {
          names.push_back(var.name);
        }
        constituent_names.emplace_back(node.name, names);
      }
 
      std::vector<ConstituentsInputConfig> constituent_configs;
      for (auto el: constituent_names){
        constituent_configs.push_back(
          createConstituentsLoaderConfig(el.first, el.second, flip_config));
      }
 
      // some additional options
      FTagOptions options;
      
      if (auto h = remap_scalar.extract(options.track_prefix)) {
        options.track_prefix = h.mapped();
      }
      if (auto h = remap_scalar.extract(options.track_link_name)) {
        options.track_link_name = h.mapped();
      }
      if (auto h = remap_scalar.extract(options.invalid_ip_key)) {
        options.invalid_ip_key = h.mapped();
      }
      options.flip = flip_config;
      options.remap_scalar = remap_scalar;
      options.track_link_type = track_link_type;
      return std::make_tuple(input_config, constituent_configs, options);
    }

createIpChecker()

std::tuple< std::function< char(const internal::Tracks &)>, std::vector< SG::AuxElement::Decorator< char > >, FTagDataDependencyNames, std::set< std::string > > FlavorTagDiscriminants::dataprep::createIpChecker	(	const lwt::GraphConfig &	gc,
		const FTagOptions &	opts
	)

Definition at line 420 of file DataPrepUtilities.cxx.

                                                         {
      using namespace internal;
      FTagDataDependencyNames deps;
      std::map<std::string, std::string> remap = opts.remap_scalar;
      std::set<std::string> used_remap;
      // dummy if there's no invalid check key
      std::function checker = [](const Tracks&) -> char {return 0;};
      // if we do have a key, return 1 for invalid
      if (!opts.invalid_ip_key.empty()) {
        std::string ip_key = opts.track_prefix + opts.invalid_ip_key;
        SG::AuxElement::ConstAccessor<char> invalid_check(ip_key);
        checker = [invalid_check](const Tracks& trs){
          for (const xAOD::TrackParticle* trk: trs) {
            if (invalid_check(*trk)) return 1;
          }
          return 0;
        };
        deps.trackInputs.insert(ip_key);
      }
      std::vector<SG::AuxElement::Decorator<char>> default_decs;
      for (const auto& output: gc.outputs) {
        std::string basename = output.first;
        std::string dec_name = basename + "_isDefaults";
        if (auto h = remap.extract(dec_name)) {
          dec_name = h.mapped();
          used_remap.insert(h.key());
        }
        default_decs.emplace_back(dec_name);
        deps.bTagOutputs.insert(dec_name);
      }
      return {checker, default_decs, deps, used_remap};
    }

getNameFlippers()

StringRegexes FlavorTagDiscriminants::dataprep::getNameFlippers

(

const FlipTagConfig &

flip_config

)

Definition at line 197 of file DataPrepUtilities.cxx.

                                                                    {
 
      std::string flip_name = "";
      if (flip_config == FlipTagConfig::FLIP_SIGN) {
        flip_name = "Flip";
      }
      else if (flip_config == FlipTagConfig::NEGATIVE_IP_ONLY) {
        flip_name = "Neg";
      }
      else if (flip_config == FlipTagConfig::SIMPLE_FLIP) {
        flip_name = "SimpleFlip";
      }
 
      StringRegexes flip_converters {
        {"(GN1[^_]*|GN2[^_]*)"_r, "$1" + flip_name},
        {"(GN1[^_]*|GN2[^_]*)_(.*)"_r, "$1" + flip_name + "_$2"},
        {"(IP[23]D)_(.*)"_r, "$1Neg_$2"},
        {"(rnnip|(?:dips|DIPS)[^_]*)_(.*)"_r, "$1flip_$2"},
        {"(JetFitter|SV1|JetFitterSecondaryVertex)_(.*)"_r, "$1Flip_$2"},
        {"(rnnip|(?:dips|DIPS)[^_]*)"_r, "$1flip"},
        {"^(DL1|DL1r[^_]*|DL1rmu|DL1d[^_]*)$"_r, "$1" + flip_name},
        {"pt|abs_eta|eta"_r, "$&"},
        {"softMuon.*|smt.*"_r, "$&"}
      };
 
      return flip_converters;
    }