Trigger.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
// contact: jmaurer@cern.ch
 
#ifndef TRIGGLOBALEFFICIENCYCORRECTION_TRIGGER_H
#define TRIGGLOBALEFFICIENCYCORRECTION_TRIGGER_H 1
 
#include "TrigGlobalEfficiencyCorrection/ImportData.h"
#include "xAODBase/ObjectType.h"
 
#include <array>
#include <algorithm>
#include <type_traits>
#include <boost/container/flat_set.hpp>
template<typename Key> using flat_set = boost::container::flat_set<Key>;
 
namespace TrigGlobEffCorr
{
 
class UnusedArg { public: static constexpr xAOD::Type::ObjectType object() { return xAOD::Type::Other; } };
 
class TriggerProperties
{
public:
    explicit constexpr TriggerProperties(TriggerType tt) : m_type(tt), m_legs{} {}
    explicit TriggerProperties(const ImportData::TrigDef& def) : m_type(def.type) { loadLegs(def, m_legs); }
    constexpr TriggerType type() const { return m_type; }
    constexpr bool valid() const
    {
        return !((m_type&TT_MASK_FLAVOUR)&~(TT_ELECTRON_FLAG|TT_MUON_FLAG|TT_PHOTON_FLAG)); 
    }
    constexpr bool mixed() const
    {
        auto x = m_type&TT_MASK_FLAVOUR;
        return (x!=TT_ELECTRON_FLAG) && (x!=TT_MUON_FLAG) && (x!=TT_PHOTON_FLAG);
    }
    constexpr unsigned nDistinctLegs() const
    {
        auto x = m_type&TT_MASK_SYMMETRY;
        if(m_type&TT_SINGLELEPTON_FLAG) return 1;
        else if(m_type&TT_DILEPTON_FLAG) return 2 - 1*(x==TT_SYM);
        else if(m_type&TT_TRILEPTON_FLAG) return (x==TT_ASYM)? 3 : 1 + 1*(mixed()||(x!=TT_SYM));
        else if((m_type&TT_TETRALEPTON_FLAG) && x==TT_SYM) return 1;
        return 0;
    }
    constexpr unsigned nDistinctLegs(xAOD::Type::ObjectType obj) const
    {
        bool firstPos = true;
        switch(obj)
        {
            case xAOD::Type::Electron:
                if(!(m_type&TT_ELECTRON_FLAG)) return 0;
                break;
            case xAOD::Type::Muon:
                if(!(m_type&TT_MUON_FLAG)) return 0;
                firstPos = (m_type&TT_PHOTON_FLAG);
                break;
            case xAOD::Type::Photon:
                if(!(m_type&TT_PHOTON_FLAG)) return 0;
                firstPos = false;
                break;
            default: return 0;
        }
        if(!mixed()) return nDistinctLegs();
        return (firstPos == (m_type&TT_X2Y_FLAG))? 1 : nDistinctLegs()-1;
    }
    template<typename Array>
    void loadLegs(const ImportData::TrigDef& src, Array& dest)
    {
        if(src.type != m_type) throw std::runtime_error ("Calculator bug"); 
        std::fill(dest.begin(), dest.end(), 0);
        if(m_type==TT_2E_MU_SYM || m_type==TT_2E_G_SYM || m_type==TT_2MU_G_SYM) 
        {
            dest[0] = src.leg[0];
            dest[1] = src.leg[2];
        }
        else 
        {
            std::copy_n(src.leg.cbegin(), nDistinctLegs(), dest.begin());
        }
    }
    
    constexpr int cbegin_offset(xAOD::Type::ObjectType obj) const
    {
        return (obj!=xAOD::Type::Electron) *(nDistinctLegs(xAOD::Type::Electron)  
            + (obj!=xAOD::Type::Muon)*nDistinctLegs(xAOD::Type::Muon));
    }
    
    constexpr auto cbegin(xAOD::Type::ObjectType obj) const
    {
        return m_legs.cbegin() + cbegin_offset(obj);
    }
    
    constexpr int cend_offset(xAOD::Type::ObjectType obj) const
    {
        return -((obj!=xAOD::Type::Photon) *(nDistinctLegs(xAOD::Type::Photon)  
            + (obj!=xAOD::Type::Muon)*nDistinctLegs(xAOD::Type::Muon)));
    }
    
    constexpr auto cend(xAOD::Type::ObjectType obj) const
    {
        return m_legs.cbegin() + nDistinctLegs() + cend_offset(obj);
    }
    
protected:
    TriggerType m_type;
    std::array<std::size_t, 4> m_legs;
};
 
template<TriggerType tt, typename CastType1 = UnusedArg, typename CastType2 = UnusedArg>
class Trigger
{
    static_assert(TriggerProperties(tt).valid(), "trigger type not supported");
private:
    static constexpr bool extraCheck(xAOD::Type::ObjectType obj) { return (object()==obj || obj==xAOD::Type::Other); }
    template<typename T> struct Optional {};
public:
    
    static constexpr TriggerType type() { return tt; }
    
    static constexpr bool mixed()
    {
        return TriggerProperties(tt).mixed();
    }
    
    static constexpr unsigned nDistinctLegs() { return TriggerProperties(tt).nDistinctLegs(); }
    
    static constexpr unsigned nDistinctLegs(xAOD::Type::ObjectType obj) { return TriggerProperties(tt).nDistinctLegs(obj); }
 
    static constexpr xAOD::Type::ObjectType object1()
    {
        if(!is3Lmix())
        {
            if(tt&TT_ELECTRON_FLAG) return xAOD::Type::Electron;
            if(tt&TT_MUON_FLAG) return xAOD::Type::Muon;
            if(tt&TT_PHOTON_FLAG) return xAOD::Type::Photon;
            return xAOD::Type::Other;
        }
        if((tt&TT_ELECTRON_FLAG) && !(tt&TT_X2Y_FLAG)) return xAOD::Type::Electron;
        if((tt&TT_PHOTON_FLAG) && (tt&TT_X2Y_FLAG)) return xAOD::Type::Photon;
        return (tt&TT_MUON_FLAG)? xAOD::Type::Muon : xAOD::Type::Other;
    }
    
    static constexpr xAOD::Type::ObjectType object2()
    {
        if(is2Lmix())
        {
            if((tt&TT_ELECTRON_FLAG) && (tt&TT_MUON_FLAG)) return xAOD::Type::Muon;
            if((tt&(TT_ELECTRON_FLAG|TT_MUON_FLAG)) && (tt&TT_PHOTON_FLAG)) return xAOD::Type::Photon;
            return xAOD::Type::Other;
        }
        else if(!is3Lmix()) return xAOD::Type::Other;   
        if((tt&TT_ELECTRON_FLAG) && (tt&TT_X2Y_FLAG)) return xAOD::Type::Electron;
        if((tt&TT_PHOTON_FLAG) && !(tt&TT_X2Y_FLAG)) return xAOD::Type::Photon;
        return (tt&TT_MUON_FLAG)? xAOD::Type::Muon : xAOD::Type::Other;
    }
    
    static constexpr xAOD::Type::ObjectType object()
    {
        if(mixed()) return xAOD::Type::Other;
        return object1();
    }
    
    static bool relevantFor(const Lepton& lepton) { return lepton.type()==object(); }
    static bool irrelevantFor(const Lepton& lepton) { return !relevantFor(lepton); }
    
    static constexpr bool is1L() { return (tt&TT_SINGLELEPTON_FLAG); }
    static constexpr bool is2Lnomix() { return (tt&TT_DILEPTON_FLAG) && !mixed(); }
    static constexpr bool is2Lasym() { return ((tt&TT_MASK_TYPE)==TT_DILEPTON_ASYM); }
    static constexpr bool is2Lsym() { return ((tt&TT_MASK_TYPE)==TT_DILEPTON_SYM); }
    static constexpr bool is3Lsym() { return ((tt&TT_MASK_TYPE)==TT_TRILEPTON_SYM) && !mixed(); }
    static constexpr bool is3Lhalfsym() { return ((tt&TT_MASK_TYPE)==TT_TRILEPTON_HALFSYM) && !mixed(); }
    static constexpr bool is2Lmix() { return (tt&TT_DILEPTON_FLAG) && mixed(); }
    static constexpr bool is3Lmix() { return (tt&TT_TRILEPTON_FLAG) && mixed(); }
    static constexpr bool is4Lsym() { return ((tt&TT_MASK_TYPE) == TT_TETRALEPTON_SYM); }
 
    
    std::array<std::size_t, nDistinctLegs()> legs;
    
    explicit Trigger()
    {
        std::fill(legs.begin(), legs.end(), 0);
    }
    
    void setDefinition(const ImportData::TrigDef& def)
    {
        TriggerProperties(tt).loadLegs(def, legs);
    }
    
    template<bool=true> std::size_t operator()(void) const
    {
        static_assert(nDistinctLegs()==1, "this function is not meaningful for this type of trigger, hence should not be used.");
        return legs[0];
    }
    
    std::size_t operator()(unsigned index) const
    {
        return legs[index];
    }
    
    template<bool=true> std::size_t operator<(const Trigger& rhs) const
    {
        static_assert(is1L(), "this function is not meaningful for this type of trigger, hence should not be used.");
        return legs[0] < rhs.legs[0];
    }
    
    explicit operator bool() const
    {
        return std::all_of(legs.cbegin(), legs.cend(), [](std::size_t x)->bool{ return x; });
    }
    
    bool operator==(const Trigger& rhs) const
    {
        return legs == rhs.legs;
    }
    
    template<xAOD::Type::ObjectType obj = object()> constexpr auto cbegin() const
    {
        return legs.cbegin() + TriggerProperties(tt).cbegin_offset(obj);
    }
    
    template<xAOD::Type::ObjectType obj = object()> constexpr auto cend() const
    {
        return legs.cend() + TriggerProperties(tt).cend_offset(obj);
    }
 
    template<typename Trig1L> auto hiddenBy(const Trig1L trig) const
        -> typename std::enable_if<Trig1L::is1L(), bool>::type
    {
        static_assert(Trig1L::is1L(), "this function is not meaningful for this type of trigger, hence should not be used.");
        constexpr auto obj = Trig1L::object();
        return std::find(cbegin<obj>(), cend<obj>(), trig()) != cend<obj>();
    }
    
    template<typename Trig1L> auto hiddenBy(const flat_set<Trig1L>& trigs) const
        -> typename std::enable_if<Trig1L::is1L(), bool>::type
    {
        static_assert(Trig1L::is1L(), "this function is not meaningful for this type of trigger, hence should not be used.");
        return std::any_of(trigs.cbegin(), trigs.cend(), [&](Trig1L t)->bool{ return hiddenBy(t); });
    }
    
    template<xAOD::Type::ObjectType obj, bool anti=false> auto side() const
        -> std::conditional_t<anti ^ (CastType1::object()==obj), CastType1, CastType2>
    {
        static_assert(mixed(), "this function is not meaningful for this type of trigger, hence should not be used.");
        static_assert(obj != xAOD::Type::Other, "implementation incomplete");
        using CastType = decltype(side<obj, anti>());
        CastType trig;
        std::copy_n(this->cbegin<CastType::object()>(), nDistinctLegs(CastType::object()), trig.legs.begin());
        return trig;
    }
    template<typename TrigX> auto side() const -> decltype(side<TrigX::object()>()) { return side<TrigX::object()>(); }
    template<typename TrigX> auto antiside() const -> decltype(side<TrigX::object(),true>()) { return side<TrigX::object(),true>(); }
    CastType1 side1() const { return side<CastType1::object()>(); }
    CastType2 side2() const { return side<CastType2::object()>(); }
 
    template<typename Trig1L> auto addTo(const flat_set<Trig1L>& trigs1L) const
        -> std::enable_if_t<Trig1L::is1L() && nDistinctLegs(Trig1L::object())==1, flat_set<Trig1L>> 
    {
        static_assert(mixed(), "this function is not meaningful for this type of trigger, hence should not be used.");
        flat_set<Trig1L> trigs(trigs1L);
        trigs.insert(side<Trig1L>());
        return trigs;
    }
    
    template<typename Trig1L> static auto anonymize(const flat_set<Trig1L>& triggers)
        -> std::enable_if_t<is1L() && tt==Trig1L::type(), const flat_set<std::size_t>&>
    {
        static_assert(sizeof(Trig1L)==sizeof(std::size_t), "invalid cast if the key sizes differ");
        return reinterpret_cast<const flat_set<std::size_t>&>(triggers);
    }
    
    template<bool=true> bool symmetric() const
    {
        static_assert(!std::is_same<CastType1, UnusedArg>::value, "this function is not meaningful for this type of trigger, hence should not be used.");
        return std::all_of(legs.cbegin()+1, legs.cend(), [&](std::size_t l)->bool{ return l==legs[0]; });
    }
 
    template<bool=true> CastType1 to_symmetric() const
    {
        static_assert(!std::is_same<CastType1, UnusedArg>::value, "this function is not meaningful for this type of trigger, hence should not be used.");
        CastType1 trig;
        trig.legs[0] = this->legs[0];
        return trig;
    }
    
    template<bool=true> std::size_t asymLeg() const
    {
        static_assert((tt&TT_MASK_SYMMETRY)==TT_HALFSYM, "this function is not meaningful for this type of trigger, hence should not be used.");
        return legs[0];
    }
    
    template<bool=true> std::size_t symLeg() const
    {
        static_assert((tt&TT_MASK_SYMMETRY)==TT_HALFSYM, "this function is not meaningful for this type of trigger, hence should not be used.");
        return legs[1];
    }
};
 
template<TriggerType, TriggerType=TT_UNKNOWN> struct TriggerClass;
 
template<TriggerType object_flag>
struct TriggerClass<object_flag, TT_UNKNOWN>
{
    static constexpr auto addObjFlag(int tt) { return static_cast<TriggerType>(tt|object_flag); }
    
    struct T_1 : public Trigger<addObjFlag(TT_SINGLELEPTON_FLAG)> {};
    struct T_2sym : public Trigger<addObjFlag(TT_DILEPTON_SYM)> {};
    struct T_2asym : public Trigger<addObjFlag(TT_DILEPTON_ASYM), T_2sym> {};
    struct T_3sym : public Trigger<addObjFlag(TT_TRILEPTON_SYM)> {};
    struct T_3halfsym : public Trigger<addObjFlag(TT_TRILEPTON_HALFSYM), T_3sym> {};
    struct T_4sym : public Trigger<addObjFlag(TT_TETRALEPTON_SYM)> {};
};
 
template<TriggerType object1_flag, TriggerType object2_flag>
struct TriggerClass
{
    using A = TriggerClass<object1_flag>;
    using B = TriggerClass<object2_flag>;
    static constexpr auto addObjFlags(int tt) { return static_cast<TriggerType>(tt|object1_flag|object2_flag); }
    
    struct T_1_1 : public Trigger<addObjFlags(TT_DILEPTON_FLAG), typename A::T_1, typename B::T_1> {};
    struct T_2sym_1 : public Trigger<addObjFlags(TT_TRILEPTON_SYM), typename A::T_2sym, typename B::T_1> {};
    struct T_2asym_1: public Trigger<addObjFlags(TT_TRILEPTON_ASYM), typename A::T_2asym, typename B::T_1> {};
    struct T_1_2sym: public Trigger<addObjFlags(TT_TRILEPTON_SYM|TT_X2Y_FLAG), typename A::T_1, typename B::T_2sym> {};
    struct T_1_2asym: public Trigger<addObjFlags(TT_TRILEPTON_SYM|TT_X2Y_FLAG), typename A::T_1, typename B::T_2asym> {};
};
 
}
 
 
#endif