Utility functions to access the different RoI objects with a single interface

Typedefs
using	HLTSeedingRoIToolDefs::AnyRoIPointer = std::variant<const eFexEM::T_RoI*, const eFexTau::T_RoI*, const jFexFwdEl::T_RoI*, const jFexTau::T_RoI*, const jFexSRJet::T_RoI*, const jFexLRJet::T_RoI*, const gFexSRJet::T_RoI*, const Muon::T_RoI*>
	std::variant of const ptr to RoI types. Note identical types are only entered once in the template (e.g. no cTau which is same type as eFexTau)
using	HLTSeedingRoIToolDefs::AnyRoIContainer = std::variant<eFexEM::T_RoIContainer, eFexTau::T_RoIContainer, jFexFwdEl::T_RoIContainer, jFexTau::T_RoIContainer, jFexSRJet::T_RoIContainer, jFexLRJet::T_RoIContainer, gFexSRJet::T_RoIContainer, Muon::T_RoIContainer>
	std::variant of RoI containers. Has to correspond directly to AnyRoIPointer types.

Functions
template<std::size_t I = 0>
std::optional< AnyRoIPointer >	HLTSeedingRoIToolDefs::roiFromLink (const xAOD::TrigComposite &tc, const std::string &linkName)
	Recursively try each type from AnyRoIPointer variant to retrieve an object from a TrigComposite link.
constexpr float	HLTSeedingRoIToolDefs::roiPhi (const AnyRoIPointer &roi)
constexpr float	HLTSeedingRoIToolDefs::roiEta (const AnyRoIPointer &roi)
constexpr unsigned int	HLTSeedingRoIToolDefs::roiWord (const AnyRoIPointer &roi)
constexpr unsigned int	HLTSeedingRoIToolDefs::roiTobEt (const AnyRoIPointer &roi)

Detailed Description

Typedef Documentation

AnyRoIContainer

using HLTSeedingRoIToolDefs::AnyRoIContainer = std::variant<eFexEM::T_RoIContainer, eFexTau::T_RoIContainer, jFexFwdEl::T_RoIContainer, jFexTau::T_RoIContainer, jFexSRJet::T_RoIContainer, jFexLRJet::T_RoIContainer, gFexSRJet::T_RoIContainer, Muon::T_RoIContainer>

std::variant of RoI containers. Has to correspond directly to AnyRoIPointer types.

Definition at line 146 of file HLTSeedingRoIToolDefs.h.

AnyRoIPointer

using HLTSeedingRoIToolDefs::AnyRoIPointer = std::variant<const eFexEM::T_RoI*, const eFexTau::T_RoI*, const jFexFwdEl::T_RoI*, const jFexTau::T_RoI*, const jFexSRJet::T_RoI*, const jFexLRJet::T_RoI*, const gFexSRJet::T_RoI*, const Muon::T_RoI*>

std::variant of const ptr to RoI types. Note identical types are only entered once in the template (e.g. no cTau which is same type as eFexTau)

Definition at line 144 of file HLTSeedingRoIToolDefs.h.

Function Documentation

roiEta()

float HLTSeedingRoIToolDefs::roiEta ( const AnyRoIPointer & roi )

constexpr

Definition at line 171 of file HLTSeedingRoIToolDefs.h.

                                                   {
    return std::visit([](auto arg) -> float {return arg->eta();}, roi);
  }

roiFromLink()

template<std::size_t I = 0>

std::optional< AnyRoIPointer > HLTSeedingRoIToolDefs::roiFromLink ( const xAOD::TrigComposite & tc, const std::string & linkName )

inline

Recursively try each type from AnyRoIPointer variant to retrieve an object from a TrigComposite link.

See https://stackoverflow.com/a/57643845

Definition at line 154 of file HLTSeedingRoIToolDefs.h.

                                                                                                        {
    if constexpr (I < std::variant_size_v<AnyRoIPointer>) {
      using T_RoIContainer = std::variant_alternative_t<I,AnyRoIContainer>;
      using T_RoI_constptr = std::variant_alternative_t<I,AnyRoIPointer>;
      using T_RoI = std::remove_const_t<std::remove_pointer_t<T_RoI_constptr>>;
      if (tc.hasObjectLink(linkName,ClassID_traits<T_RoIContainer>::ID())) {
        return AnyRoIPointer{tc.object<T_RoI>(linkName)};
      }
      return roiFromLink<I+1>(tc,linkName);
    }
    return std::nullopt;
  }

roiPhi()

float HLTSeedingRoIToolDefs::roiPhi ( const AnyRoIPointer & roi )

constexpr

Definition at line 167 of file HLTSeedingRoIToolDefs.h.

                                                   {
    return std::visit([](auto arg) -> float {return arg->phi();}, roi);
  }

roiTobEt()

unsigned int HLTSeedingRoIToolDefs::roiTobEt ( const AnyRoIPointer & roi )

constexpr

Definition at line 206 of file HLTSeedingRoIToolDefs.h.

                                                            {
    return std::visit([](auto arg) -> float {
      using T = std::decay_t<decltype(arg)>;
      if constexpr (std::is_same_v<T, const eFexEM::T_RoI*>) {
        return (arg->*eFexEM::F_TobEtGetter)();
      }
      if constexpr (std::is_same_v<T, const eFexTau::T_RoI*>) {
        return (arg->*eFexTau::F_TobEtGetter)();
      }
      if constexpr (std::is_same_v<T, const jFexFwdEl::T_RoI*>) {
        return (arg->*jFexFwdEl::F_TobEtGetter)();
      }
      if constexpr (std::is_same_v<T, const jFexTau::T_RoI*>) {
        return (arg->*jFexTau::F_TobEtGetter)();
      }
      if constexpr (std::is_same_v<T, const jFexSRJet::T_RoI*>) {
        return (arg->*jFexSRJet::F_TobEtGetter)();
      }
      if constexpr (std::is_same_v<T, const jFexLRJet::T_RoI*>) {
        return (arg->*jFexLRJet::F_TobEtGetter)();
      }
      if constexpr (std::is_same_v<T, const gFexSRJet::T_RoI*>) {
        return (arg->*gFexSRJet::F_TobEtGetter)();
      }
      if constexpr (std::is_same_v<T, const Muon::T_RoI*>) {
        return (arg->*Muon::F_TobEtGetter)();
      }
      return 0;
    }, roi);
  }

roiWord()

unsigned int HLTSeedingRoIToolDefs::roiWord ( const AnyRoIPointer & roi )

constexpr

Definition at line 175 of file HLTSeedingRoIToolDefs.h.

                                                           {
    return std::visit([](auto arg) -> float {
      using T = std::decay_t<decltype(arg)>;
      if constexpr (std::is_same_v<T, const eFexEM::T_RoI*>) {
        return (arg->*eFexEM::F_RoIWordGetter)();
      }
      if constexpr (std::is_same_v<T, const eFexTau::T_RoI*>) {
        return (arg->*eFexTau::F_RoIWordGetter)();
      }
      if constexpr (std::is_same_v<T, const jFexFwdEl::T_RoI*>) {
        return (arg->*jFexFwdEl::F_RoIWordGetter)();
      }
      if constexpr (std::is_same_v<T, const jFexTau::T_RoI*>) {
        return (arg->*jFexTau::F_RoIWordGetter)();
      }
      if constexpr (std::is_same_v<T, const jFexSRJet::T_RoI*>) {
        return (arg->*jFexSRJet::F_RoIWordGetter)();
      }
      if constexpr (std::is_same_v<T, const jFexLRJet::T_RoI*>) {
        return (arg->*jFexLRJet::F_RoIWordGetter)();
      }
      if constexpr (std::is_same_v<T, const gFexSRJet::T_RoI*>) {
        return (arg->*gFexSRJet::F_RoIWordGetter)();
      }
      if constexpr (std::is_same_v<T, const Muon::T_RoI*>) {
        return (arg->*Muon::F_RoIWordGetter)();
      }
      return 0;
    }, roi);
  }