TrigGlobEffCorr::Calculator::Helper Class Reference

Collaboration diagram for TrigGlobEffCorr::Calculator::Helper:

Classes
struct	BindPackedParam
	to decorate the parameters of the findAndBind() function(s) More...
struct	NoSuchTrigger
struct	Optional

Public Member Functions
	Helper (const std::vector< TrigDef > &defs)
	Helper (Helper &&)=default
bool	duplicates () const
bool	findAndBindFunction ()
	top-level function More...

Public Attributes
std::function< bool(Calculator *, const LeptonList &, unsigned, Efficiencies &)>	m_formula

Protected Member Functions
template<TriggerType object_flag>
bool	findAndBindFunction ()
	for combinations with a single flavour present More...
template<TriggerType object1_flag, TriggerType object2_flag>
bool	findAndBindFunction ()
	for combinations with two flavours present More...
template<typename... Trigs>
bool	bindFunction ()
template<typename Param >
auto	extract ()

Protected Attributes
std::vector< TrigDef >	m_defs
unsigned	m_n1L = 0
unsigned	m_n2L = 0
unsigned	m_n3L = 0
unsigned	m_n4L = 0

Detailed Description

Definition at line 211 of file Calculator.h.

Constructor & Destructor Documentation

Helper() [1/2]

Calculator::Helper::Helper

(

const std::vector< TrigDef > &

defs

)

Definition at line 1226 of file Calculator.cxx.

                                                       :
    m_formula(nullptr), m_defs(defs)
{
}

Helper() [2/2]

TrigGlobEffCorr::Calculator::Helper::Helper ( Helper &&  )

default

Member Function Documentation

bindFunction()

template<typename... Trigs>

bool Calculator::Helper::bindFunction ( )

protected

Definition at line 1291 of file Calculator.cxx.

{
    for(auto& def : m_defs) def.used = false;
    using fnptr = bool(Calculator::*)(const LeptonList&, unsigned, typename BindPackedParam<Trigs>::ArgType..., Efficiencies&);
    try
    {
        m_formula = std::bind<fnptr>(&Calculator::globalEfficiency, ::_1, ::_2, ::_3, extract<BindPackedParam<Trigs>>()..., ::_4);
        if(std::all_of(m_defs.cbegin(), m_defs.cend(), [](auto& def){return def.used;})) return true;
    }
    catch(NoSuchTrigger){}
    m_formula = nullptr;
    return false;
}

duplicates()

bool Calculator::Helper::duplicates

(

)

const

Definition at line 1231 of file Calculator.cxx.

{
    for(auto itr1=m_defs.cbegin(); itr1!=m_defs.cend(); ++itr1)
        for(auto itr2=itr1+1; itr2!=m_defs.cend(); ++itr2)
            if(itr1->type==itr2->type && itr1->leg==itr2->leg) return true;
    return false;
}

extract()

template<typename Param >

auto Calculator::Helper::extract ( )

protected

Definition at line 1276 of file Calculator.cxx.

{
    std::remove_cv_t<std::remove_reference_t<typename Param::ArgType>> trigs;
    for(auto& def : m_defs)
    {
        if(def.used || def.type!=Param::TrigType::type()) continue;
        def.used = true;
        Param::add(trigs, def);
        if(!Param::multiple()) break;
    }
    if(!Param::optional() && !Param::valid(trigs)) throw NoSuchTrigger();
    return trigs;
}

findAndBindFunction() [1/3]

bool Calculator::Helper::findAndBindFunction

(

)

top-level function

First check if the trigger combination refers to a single object type

Then try to rely on available formulas for combinations with two object types

As a last resort, maybe factorizing helps

check there's no mixed-flavour trigger involving 'obj_flag'

Definition at line 1394 of file Calculator.cxx.

{
    auto countTriggers = [&](auto nlep_flag) { return std::count_if(m_defs.cbegin(), m_defs.cend(), [=](auto& def){return def.type&nlep_flag;}); };
    m_n1L = countTriggers(TT_SINGLELEPTON_FLAG);
    m_n2L = countTriggers(TT_DILEPTON_FLAG);
    m_n3L = countTriggers(TT_TRILEPTON_FLAG);
    m_n4L = countTriggers(TT_TETRALEPTON_FLAG);
    auto exclusively = [&](auto obj_flags) { return std::none_of(m_defs.cbegin(), m_defs.cend(), [=](auto& def){return def.type&TT_MASK_FLAVOUR&~obj_flags;}); };
 
    if(exclusively(TT_ELECTRON_FLAG)) return findAndBindFunction<TT_ELECTRON_FLAG>();
    if(exclusively(TT_MUON_FLAG)) return findAndBindFunction<TT_MUON_FLAG>();
    if(exclusively(TT_PHOTON_FLAG)) return findAndBindFunction<TT_PHOTON_FLAG>();
 
    bool success = false;
    if(exclusively(TT_ELECTRON_FLAG|TT_MUON_FLAG)) success = findAndBindFunction<TT_ELECTRON_FLAG,TT_MUON_FLAG>();
    else if(exclusively(TT_ELECTRON_FLAG|TT_PHOTON_FLAG)) success = findAndBindFunction<TT_ELECTRON_FLAG,TT_PHOTON_FLAG>();
    else if(exclusively(TT_MUON_FLAG|TT_PHOTON_FLAG)) success = findAndBindFunction<TT_MUON_FLAG,TT_PHOTON_FLAG>();
    if(success) return true;
    
    std::vector<Helper> helpers;
    for(auto obj_flag : {TT_ELECTRON_FLAG, TT_MUON_FLAG, TT_PHOTON_FLAG})
    {
        if(std::any_of(m_defs.cbegin(), m_defs.cend(), 
            [&](auto& def){ return (def.type&obj_flag) && TriggerProperties(def.type).mixed();})) continue;
        std::vector<ImportData::TrigDef> trigs1, trigs2;
        std::partition_copy(m_defs.begin(), m_defs.end(), std::back_inserter(trigs1), std::back_inserter(trigs2), [&](auto& def){ return (def.type&obj_flag); });
        m_defs.swap(trigs2);
        if(!trigs1.size()) continue;
        helpers.emplace_back(trigs1);
        if(!helpers.back().findAndBindFunction()) return false;
    }
    if(helpers.size())
    {
        if(m_defs.size())
        {
            if(!findAndBindFunction()) return false;
            if(helpers.size() == 1) m_formula = std::bind(&Calculator::globalEfficiency_Factorized2, ::_1, ::_2, ::_3, 
                std::move(m_formula), std::move(helpers[0].m_formula), ::_4);
            else if(helpers.size()==2) m_formula = std::bind(&Calculator::globalEfficiency_Factorized3, ::_1, ::_2, ::_3, 
                std::move(m_formula), std::move(helpers[0].m_formula), std::move(helpers[1].m_formula), ::_4);
            else
            {
                m_formula = nullptr;
                return false;
            }
        }
        else    
        {
            if(helpers.size() == 2) m_formula = std::bind(&Calculator::globalEfficiency_Factorized2, ::_1, ::_2, ::_3, 
                std::move(helpers[0].m_formula), std::move(helpers[1].m_formula), ::_4);
            else if(helpers.size() == 3) m_formula = std::bind(&Calculator::globalEfficiency_Factorized3, ::_1, ::_2, ::_3, 
                std::move(helpers[0].m_formula), std::move(helpers[1].m_formula), std::move(helpers[2].m_formula), ::_4);
            else return false;
        }
        return true;
    }
 
    return false;
}

findAndBindFunction() [2/3]

template<TriggerType object_flag>

bool Calculator::Helper::findAndBindFunction ( )

protected

for combinations with a single flavour present

Definition at line 1306 of file Calculator.cxx.

{
    using A = TriggerClass<object_flag>;
    using A1L = flat_set<typename A::T_1>;
    using A_2sym = typename A::T_2sym;
    using A_2asym = typename A::T_2asym;
    if(m_n2L + m_n3L + m_n4L == 0)
    {
        return bindFunction<typename A::T_1>() || bindFunction<A1L>();
    }
    else if(m_n2L==1 && m_n3L + m_n4L == 0)
    {
        return bindFunction<A_2sym>() || bindFunction<A_2asym>()
            || bindFunction<A_2sym, A1L>() || bindFunction<A_2asym, A1L>();
    }
    else if(m_n2L==2 && m_n3L + m_n4L == 0)
    {
        return bindFunction<A_2sym, A_2sym, Optional<A1L>>() || bindFunction<A_2asym, A_2sym, Optional<A1L>>();
    }
    else if(m_n3L==1 && m_n1L + m_n2L + m_n4L == 0)
    {
        return bindFunction<typename A::T_3sym>() || bindFunction<typename A::T_3halfsym>();
    }
    else if(m_n4L==1 && m_n1L + m_n2L + m_n3L == 0)
    {
        return bindFunction<typename A::T_4sym>();
    }
    return false;
}

findAndBindFunction() [3/3]

template<TriggerType object1_flag, TriggerType object2_flag>

bool Calculator::Helper::findAndBindFunction ( )

protected

for combinations with two flavours present

this only deals with the presence of mixed triggers

checked if triggers can be factorized = no mixed trigger in the combination.

2 dilepton triggers

3 dilepton triggers

6 dilepton triggers

Definition at line 1337 of file Calculator.cxx.

{
    using A = TriggerClass<object_flag1>;
    using B = TriggerClass<object_flag2>;
    using AB = TriggerClass<object_flag1, object_flag2>;
    using A_1 = typename A::T_1;
    using B_1 = typename B::T_1;        
    using OA1L = Optional<flat_set<A_1>>;
    using OB1L = Optional<flat_set<B_1>>;
    using A_2sym = typename A::T_2sym;
    using B_2sym = typename B::T_2sym;
    using A_2asym = typename A::T_2asym;
    using B_2asym = typename B::T_2asym;
    using AB_1_1 = typename AB::T_1_1;
    
    if(m_n1L>0 && m_n2L + m_n3L + m_n4L == 0)
    {
        return bindFunction<A_1, B_1>() || bindFunction<flat_set<A_1>, flat_set<B_1>>();
    }
    else if(m_n2L==1 && m_n3L + m_n4L == 0)
    {   // one dilepton trigger (+ single-lepton triggers)
        return bindFunction<AB_1_1>() || bindFunction<AB_1_1, flat_set<A_1>, flat_set<B_1>>();
    }
    else if(m_n2L>=2 && m_n2L<=6 && m_n3L + m_n4L == 0)
    {   // several dilepton triggers (+ single-lepton triggers)
        return 
               bindFunction<A_2sym, AB_1_1>() || bindFunction<A_2asym, AB_1_1>()
            || bindFunction<B_2sym, AB_1_1>() || bindFunction<B_2asym, AB_1_1>()
            || bindFunction<Optional<A_2sym>, Optional<B_2sym>, Optional<AB_1_1>, OA1L, OB1L>()
            || bindFunction<Optional<A_2asym>, Optional<B_2sym>, Optional<AB_1_1>, OA1L, OB1L>()
            || bindFunction<Optional<A_2sym>, Optional<B_2asym>, Optional<AB_1_1>, OA1L, OB1L>()
            || bindFunction<Optional<A_2asym>, Optional<B_2asym>, Optional<AB_1_1>, OA1L, OB1L>()
            || bindFunction<Optional<A_2sym>, Optional<A_2sym>, Optional<B_2sym>, Optional<B_2sym>, Optional<AB_1_1>, Optional<AB_1_1>, OA1L, OB1L>()
            || bindFunction<Optional<A_2asym>, Optional<A_2sym>, Optional<B_2sym>, Optional<B_2sym>, Optional<AB_1_1>, Optional<AB_1_1>, OA1L, OB1L>()
            || bindFunction<Optional<A_2sym>, Optional<A_2sym>, Optional<B_2asym>, Optional<B_2sym>, Optional<AB_1_1>, Optional<AB_1_1>, OA1L, OB1L>()
            || bindFunction<Optional<A_2asym>, Optional<A_2sym>, Optional<B_2asym>, Optional<B_2sym>, Optional<AB_1_1>, Optional<AB_1_1>, OA1L, OB1L>();
    }
    else if(m_n3L==1 && m_n1L + m_n2L + m_n4L == 0)
    {   // one mixed trilepton trigger
        return bindFunction<typename AB::T_2sym_1>() || bindFunction<typename AB::T_1_2sym>()
            ||  bindFunction<typename AB::T_2asym_1>() || bindFunction<typename AB::T_1_2asym>();
    }
    else if(m_n3L==2 && m_n1L + m_n2L + m_n4L == 0)
    {   // two mixed trilepton triggers
        return bindFunction<typename AB::T_2sym_1, typename AB::T_1_2sym>() 
            || bindFunction<typename AB::T_2asym_1, typename AB::T_1_2sym>()
            || bindFunction<typename AB::T_2sym_1, typename AB::T_1_2asym>() 
            || bindFunction<typename AB::T_2asym_1, typename AB::T_1_2asym>();
    }
    return false;
}

Member Data Documentation

m_defs

std::vector<TrigDef> TrigGlobEffCorr::Calculator::Helper::m_defs

protected

Definition at line 223 of file Calculator.h.

m_formula

std::function<bool(Calculator*,const LeptonList&,unsigned,Efficiencies&)> TrigGlobEffCorr::Calculator::Helper::m_formula

Definition at line 218 of file Calculator.h.

m_n1L

unsigned TrigGlobEffCorr::Calculator::Helper::m_n1L = 0

protected

Definition at line 224 of file Calculator.h.

m_n2L

unsigned TrigGlobEffCorr::Calculator::Helper::m_n2L = 0

protected

Definition at line 224 of file Calculator.h.

m_n3L

unsigned TrigGlobEffCorr::Calculator::Helper::m_n3L = 0

protected

Definition at line 224 of file Calculator.h.

m_n4L

unsigned TrigGlobEffCorr::Calculator::Helper::m_n4L = 0

protected

Definition at line 224 of file Calculator.h.

---

The documentation for this class was generated from the following files:

• Calculator.h
• Calculator.cxx