detail Namespace Reference

Typedefs
using	CountIParticle_t
using	CountTrackParticle_t
using	JetCondTag_t
using	JetTag_t
template<typename T>
using	defaultAccessor_t = decltype(defaultAccessor<T>)
using	uchar = unsigned char
using	uint = unsigned int
using	ushort = unsigned short
using	ull = unsigned long long
using	ul = unsigned long
using	ll = long long

Functions
std::pair< std::string, int >	extract_histogram_tag (const std::string &histo_name)
	Extract tag/LB number from per-LBN histogram name.
bool	isCustom (const Primitive &p)
bool	isCustom (const Primitive::Type &t)
template<typename T, typename I, typename A, typename S = T>
std::function< T(I)>	get (const std::string &source, A ass, T def)
template<typename T, typename A = defaultAccessor_t<T>>
void	addInput (T &c, const Primitive &input, A a=defaultAccessor< T >)

Variables
template<typename T>
auto	defaultAccessor = [](typename T::input_type in){ return in; }

Typedef Documentation

CountIParticle_t

using detail::CountIParticle_t

Initial value:

 FlavorTagDiscriminants::LinkCounterAlg<
    xAOD::IParticleContainer, xAOD::IParticleContainer>

Definition at line 9 of file CountIParticleAlg.h.

CountTrackParticle_t

using detail::CountTrackParticle_t

Initial value:

 FlavorTagDiscriminants::LinkCounterAlg<
    xAOD::TrackParticleContainer, xAOD::BTaggingContainer>

Definition at line 10 of file CountTrackParticleAlg.h.

defaultAccessor_t

template<typename T>

using detail::defaultAccessor_t = decltype(defaultAccessor<T>)

Definition at line 41 of file PrimitiveHelpers.h.

JetCondTag_t

using detail::JetCondTag_t

Initial value:

 FlavorTagInference::DecoratorAlg<
    xAOD::JetContainer,
    IJetTagConditionalDecorator,
    xAOD::TrackParticleContainer
    >

Definition at line 17 of file JetTagConditionalDecoratorAlg.h.

JetTag_t

using detail::JetTag_t

Initial value:

 FlavorTagInference::DecoratorAlg<
    xAOD::JetContainer,
    IJetTagDecorator,
    xAOD::TrackParticleContainer
    >

Definition at line 15 of file JetTagDecoratorAlg.h.

ll

using detail::ll = long long

Definition at line 48 of file PrimitiveHelpers.h.

uchar

using detail::uchar = unsigned char

Definition at line 43 of file PrimitiveHelpers.h.

uint

using detail::uint = unsigned int

Definition at line 44 of file PrimitiveHelpers.h.

ul

using detail::ul = unsigned long

Definition at line 47 of file PrimitiveHelpers.h.

ull

using detail::ull = unsigned long long

Definition at line 46 of file PrimitiveHelpers.h.

ushort

using detail::ushort = unsigned short

Definition at line 45 of file PrimitiveHelpers.h.

Function Documentation

addInput()

template<typename T, typename A = defaultAccessor_t<T>>

void detail::addInput	(	T &	c,
		const Primitive &	input,
		A	a = defaultAccessor<T> )

Definition at line 51 of file PrimitiveHelpers.h.

                                                                      {
    using I = typename T::input_type;
    using Tp = Primitive::Type;
    std::string s = input.source;
    std::string t = input.target.empty() ? input.source : input.target;
    const auto h = H5Utils::Compression::HALF_PRECISION;
    const char cz = char(0);
    const char cm = char(-1);
    const char sm = short(-1);
    switch (input.type) {
      case Tp::PRECISION_CUSTOM: // intentional fall-through
      case Tp::CUSTOM: throw std::logic_error("custom type unsupported");
      case Tp::UCHAR: c.add(t, get<uchar,I,A>(s,a,cz), cz); return;
      case Tp::CHAR: c.add(t, get<char,I,A>(s,a,cm), cm); return;
      case Tp::USHORT: c.add(t, get<ushort,I,A>(s,a,cz), cz); return;
      case Tp::SHORT: c.add(t, get<short,I,A>(s,a,sm), sm); return;
      case Tp::UINT: c.add(t, get<uint,I,A>(s,a,0), 0); return;
      case Tp::INT: c.add(t, get<int,I,A>(s,a,-1), -1); return;
      case Tp::ULONG: c.add(t, get<ul,I,A>(s,a,0), 0); return;
      case Tp::LONG: c.add(t, get<long,I,A>(s,a,-1), -1); return;
      case Tp::ULL: c.add(t, get<ull,I,A>(s,a,0), 0); return;
      case Tp::LL: c.add(t, get<ll,I,A>(s,a,-1), -1); return;
      case Tp::HALF: c.add(t, get<float,I,A>(s,a,NAN), NAN, h); return;
      case Tp::FLOAT: c.add(t, get<float,I,A>(s,a,NAN), NAN); return;
      case Tp::DOUBLE: c.add(t, get<double,I,A>(s,a,NAN), NAN); return;
      case Tp::UINT2UCHAR: c.add(t, get<uchar,I,A,uint>(s,a,0), 0); return;
      case Tp::INT2CHAR: c.add(t, get<char,I,A,int>(s,a,cm), cm); return;
      case Tp::UINT2USHORT: c.add(t, get<ushort,I,A,uint>(s,a,0), 0); return;
      case Tp::INT2SHORT: c.add(t, get<short,I,A,int>(s,a,sm), sm); return;
      case Tp::UL2ULL: c.add(t, get<ull,I,A,ul>(s,a,0),0); return;
    }
  }

extract_histogram_tag()

std::pair< std::string, int > detail::extract_histogram_tag

(

const std::string &

histo_name

)

Extract tag/LB number from per-LBN histogram name.

This method supports naming conventions used in run2 and run3. It returns a histogram hame without LB number in it and a tag (LBN) extracted from the name. If histogram name does not have LBN in it then the name is returned without any change, and tag is set to -1.

Definition at line 16 of file extract_histogram_tag.cxx.

{
    std::smatch what;
    if (std::regex_match(histo_name, what, ::lbRegex_run2)) {
        try {
            int tag = std::stoi(what.str(1));
            return std::make_pair(what[2], tag);
        } catch(std::exception &ex) {
            // should not happen but be defensive and just ignore it
        }
    }
    if (std::regex_match(histo_name, what, ::lbRegex_run3)) {
        std::string const tagStr = what[3].length() > 0 ? what.str(3) : what.str(4);
        try {
            int tag = std::stoi(tagStr);
            return std::make_pair(what[1], tag);
        } catch(std::exception &ex) {
            // should not happen but be defensive and just ignore it
        }
    }
    return std::make_pair(histo_name, -1);
}

get()

template<typename T, typename I, typename A, typename S = T>

std::function< T(I)> detail::get	(	const std::string &	source,
		A	ass,
		T	def )

Definition at line 24 of file PrimitiveHelpers.h.

                                                                {
    SG::AuxElement::ConstAccessor<S> acc(source);
    using rettype = decltype(ass(std::declval<I>()));
    if constexpr (std::is_pointer<rettype>::value) {
      return [acc, ass, def](I in) -> T {
        const auto* associated = ass(in);
        if (!associated) return def;
        return acc(*associated);
      };
    } else {
      return [acc, ass](I in) -> T { return acc(ass(in)); };
    }
  }

isCustom() [1/2]

bool detail::isCustom

(

const Primitive &

p

)

Definition at line 10 of file PrimitiveHelpers.cxx.

                                    {
    return isCustom(p.type);
  }

isCustom() [2/2]

bool detail::isCustom

(

const Primitive::Type &

t

)

Definition at line 13 of file PrimitiveHelpers.cxx.

                                        {
    using Tp = Primitive::Type;
    return std::unordered_set {
      Tp::CUSTOM, Tp::PRECISION_CUSTOM
    }.count(t);
  }

Variable Documentation

defaultAccessor

template<typename T>

auto detail::defaultAccessor = [](typename T::input_type in){ return in; }

Definition at line 39 of file PrimitiveHelpers.h.

{ return in; };