Calculator.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
// contact: jmaurer@cern.ch
 
#include "TrigGlobalEfficiencyCorrection/Calculator.h"
 
#include <iterator>
#include <random>
 
#include "TrigGlobalEfficiencyCorrection/ImportData.h"
#include "TrigGlobalEfficiencyCorrection/Lepton.h"
#include "TrigGlobalEfficiencyCorrection/Trigger.h"
 
using namespace TrigGlobEffCorr;
using std::placeholders::_1;
using std::placeholders::_2;
using std::placeholders::_3;
using std::placeholders::_4;
 
Calculator::Calculator(TrigGlobalEfficiencyCorrectionTool& parent,
                       unsigned nPeriodsToReserve)
    : asg::AsgMessaging(&parent), m_parent(&parent) {
  msg().setLevel(parent.msg().level());
  m_periods.reserve(nPeriodsToReserve);
}
 
bool Calculator::addPeriod(ImportData& data,
                           const std::pair<unsigned, unsigned>& boundaries,
                           const std::string& combination, bool useToys,
                           std::size_t& uniqueElectronLeg,
                           std::size_t& uniquePhotonLeg) {
  bool success = true;
  m_parent = data.getParent();
 
  auto triggers = data.parseTriggerString(combination, success);
  if (!success)
    return false;
  if (!triggers.size()) {
    ATH_MSG_ERROR("The trigger combination is empty!");
    return false;
  }
 
  if (!findUniqueLeg(xAOD::Type::Electron, uniqueElectronLeg, triggers))
    return false;
  if (!findUniqueLeg(xAOD::Type::Photon, uniquePhotonLeg, triggers))
    return false;
 
  Helper helper(triggers);
  if (helper.duplicates()) {
    ATH_MSG_ERROR("The following combination of triggers contains duplicates: "
                  << combination);
    return false;
  }
  if (!useToys) {
    success = helper.findAndBindFunction();
    if (!helper.m_formula) {
      ATH_MSG_ERROR(
          "This trigger combination is currently not supported with an "
          "explicit formula (you may use toys instead, slower): "
          << combination);
      return false;
    }
  } else {
    helper.m_formula = std::bind(&Calculator::globalEfficiency_Toys, ::_1, ::_2,
                                 ::_3, triggers, ::_4);
  }
  if (success) {
    if (data.adaptTriggerListForTriggerMatching(triggers)) {
      m_periods.emplace_back(boundaries, std::move(helper.m_formula),
                             std::move(triggers));
    } else {
      if (m_parent->m_validTrigMatchTool)
        return false;
      m_periods.emplace_back(boundaries, std::move(helper.m_formula));
    }
  } else {
    ATH_MSG_ERROR(
        "Unspecified error occurred while trying to find the formula for the "
        "trigger combination "
        << combination);
  }
  return success;
}
 
bool Calculator::findUniqueLeg(xAOD::Type::ObjectType obj,
                               std::size_t& uniqueLeg,
                               const std::vector<TrigDef>& defs) {
  if (uniqueLeg)
    return true;  
  for (auto& def : defs) {
    TriggerProperties tp(def);
    for (auto itr = tp.cbegin(obj); itr != tp.cend(obj); ++itr) {
      if (uniqueLeg && uniqueLeg != *itr) {
        ATH_MSG_ERROR(
            "The property 'ListOfLegsPerTool' needs to be filled as the "
            "specified trigger combination involves several electron (or "
            "photon) trigger legs");
        return false;
      }
      uniqueLeg = *itr;
    }
  }
  return true;
}
 
const Calculator::Period* Calculator::getPeriod(unsigned runNumber) const {
  auto period =
      std::find_if(m_periods.cbegin(), m_periods.cend(), [=](const Period& p) {
        return runNumber >= p.m_boundaries.first &&
               runNumber <= p.m_boundaries.second;
      });
  if (period == m_periods.end()) {
    ATH_MSG_ERROR("No trigger combination has been specified for run "
                  << runNumber);
    return nullptr;
  }
  return &*period;
}
 
bool Calculator::compute(TrigGlobalEfficiencyCorrectionTool& parent,
                         const LeptonList& leptons, unsigned runNumber,
                         Efficiencies& efficiencies) {
  m_parent = &parent;
  m_forceUnitSF = false;
  auto period = getPeriod(runNumber);
  if (!period)
    return false;
  m_cachedEfficiencies.clear();
  bool success = period->m_formula &&
                 period->m_formula(this, leptons, runNumber, efficiencies);
  if (m_forceUnitSF) {
    efficiencies.data() = 1.;
    efficiencies.mc() = 1.;
    success = true;
  }
  return success;
}
 
bool Calculator::checkTriggerMatching(
    TrigGlobalEfficiencyCorrectionTool& parent, bool& matched,
    const LeptonList& leptons, unsigned runNumber) {
  matched = false;
  m_parent = &parent;
  auto period = getPeriod(runNumber);
  if (!period)
    return false;
  if (!period->m_triggers.size()) {
    ATH_MSG_ERROR("Empty list of triggers for run number " << runNumber);
    return false;
  }
  auto& trigMatchTool = m_parent->m_trigMatchTool;
 
  const unsigned nLep = leptons.size();
  std::vector<flat_set<std::size_t>> validLegs(leptons.size());
  for (unsigned i = 0; i < nLep; ++i) {
    if (!fillListOfLegsFor(leptons[i], period->m_triggers, validLegs[i]))
      return false;
  }
 
  std::vector<flat_set<std::size_t>> firedLegs;
  std::vector<const xAOD::IParticle*> trigLeptons;
  const std::size_t magicWordHLT = 0xf7b8b87ef2917d66;
 
  for (auto& trig : period->m_triggers) {
    auto itr = m_parent->m_dictionary.find(trig.name ^ magicWordHLT);
    if (itr == m_parent->m_dictionary.end()) {
      itr = m_parent->m_dictionary
                .emplace(trig.name ^ magicWordHLT,
                         "HLT_" + m_parent->m_dictionary.at(trig.name))
                .first;
    }
    const std::string& chain = itr->second;
 
    unsigned nLegs = 0;
    if (trig.type & TT_SINGLELEPTON_FLAG)
      nLegs = 1;
    else if (trig.type & TT_DILEPTON_FLAG)
      nLegs = 2;
    else if (trig.type & TT_TRILEPTON_FLAG)
      nLegs = 3;
    else {
      ATH_MSG_ERROR("Unsupported trigger (type = "
                    << std::hex << trig.type << std::dec << ") " << chain);
      return false;
    }
    firedLegs.resize(nLegs);
    trigLeptons.resize(nLegs);
    for (unsigned i0 = 0; i0 < nLep; ++i0) {
      firedLegs[0].swap(validLegs[i0]);  
      trigLeptons[0] = leptons[i0].particle();
      if (nLegs == 1) {
        if (canTriggerBeFired(
                trig, firedLegs)  
            && trigMatchTool->match(trigLeptons, chain))
          return (matched = true);
      } else
        for (unsigned i1 = i0 + 1; i1 < nLep; ++i1) {
          firedLegs[1].swap(validLegs[i1]);
          trigLeptons[1] = leptons[i1].particle();
          if (nLegs == 2) {
            if (canTriggerBeFired(trig, firedLegs) &&
                trigMatchTool->match(trigLeptons, chain))
              return (matched = true);
          } else
            for (unsigned i2 = i1 + 1; i2 < nLep; ++i2) {
              firedLegs[2].swap(validLegs[i2]);
              trigLeptons[2] = leptons[i2].particle();
              if (canTriggerBeFired(trig, firedLegs) &&
                  trigMatchTool->match(trigLeptons, chain))
                return (matched = true);
              firedLegs[2].swap(validLegs[i2]);
            }
          firedLegs[1].swap(validLegs[i1]);
        }
      firedLegs[0].swap(
          validLegs[i0]);  
    }
  }
  return true;
}
 
bool Calculator::getRelevantTriggersForUser(
    TrigGlobalEfficiencyCorrectionTool& parent,
    std::vector<std::string>& triggers, unsigned runNumber) {
  triggers.clear();
  m_parent = &parent;
  auto period = getPeriod(runNumber);
  if (!period)
    return false;
  if (!period->m_triggers.size()) {
    ATH_MSG_ERROR("Empty list of triggers for run number "
                  << runNumber
                  << " (was there a configuration issue? please check for "
                     "warnings during initialization)");
    return false;
  }
  bool success = true;
  auto notfound = parent.m_dictionary.end();
  for (auto& trig : period->m_triggers) {
    auto itr = parent.m_dictionary.find(trig.name);
    if (itr == notfound) {
      ATH_MSG_ERROR("can't retrieve name of trigger with hash "
                    << trig.name
                    << " (shouldn't happen; contact tool developers!)");
      success = false;
    } else
      triggers.push_back(itr->second);
  }
  if (!success)
    triggers.clear();
  return success;
}
 
Efficiencies Calculator::getCachedTriggerLegEfficiencies(const Lepton& lepton,
                                                         unsigned runNumber,
                                                         std::size_t leg,
                                                         bool& success) {
  auto insertion = m_cachedEfficiencies.emplace(std::make_pair(&lepton, leg),
                                                Efficiencies());
  Efficiencies& efficiencies = insertion.first->second;
  if (insertion.second) {
    auto res = TrigGlobalEfficiencyCorrectionTool::TLE_ERROR;
    switch (lepton.type()) {
      case xAOD::Type::Electron:
        res = m_parent->getTriggerLegEfficiencies(
            lepton.electron(), runNumber, leg, lepton.tag(), efficiencies);
        break;
      case xAOD::Type::Muon:
        res = m_parent->getTriggerLegEfficiencies(lepton.muon(), runNumber, leg,
                                                  lepton.tag(), efficiencies);
        break;
      case xAOD::Type::Photon:
        res = m_parent->getTriggerLegEfficiencies(
            lepton.photon(), runNumber, leg, lepton.tag(), efficiencies);
        break;
      default:
        ATH_MSG_ERROR("Unsupported particle type");
    }
    switch (res) {
      case TrigGlobalEfficiencyCorrectionTool::TLE_OK:
        break;
      case TrigGlobalEfficiencyCorrectionTool::TLE_UNAVAILABLE:
        m_forceUnitSF = true;
        break;
      case TrigGlobalEfficiencyCorrectionTool::TLE_ERROR:
        [[fallthrough]];
      default:
        success = false;
        efficiencies.data() = -777.;
        efficiencies.mc() = -777.;
    }
  }
  if (efficiencies.mc() == -777. && !m_forceUnitSF)
    success = false;
  return efficiencies;
}
 
template <typename Trig1L>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig1L trig,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig1L::is1L(), bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One1L() at line "
                << __LINE__);
  if (!trig) {
    globalEfficiencies = {0.};
    return true;
  }
  globalEfficiencies = {1.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig.irrelevantFor(lepton) || !aboveThreshold(lepton, trig()))
      continue;
    auto efficiencies =
        getCachedTriggerLegEfficiencies(lepton, runNumber, trig(), success);
    globalEfficiencies *= ~efficiencies;
  }
  globalEfficiencies = ~globalEfficiencies;
  return success;
}
 
template <typename Trig1L_obj1, typename Trig1L_obj2>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig1L_obj1 trig1,
                                  const Trig1L_obj2 trig2,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig1L_obj1::is1L() && Trig1L_obj2::is1L() &&
                            Trig1L_obj1::object() != Trig1L_obj2::object(),
                        bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two1L() at line "
                << __LINE__);
  if (!trig1)
    return globalEfficiency(leptons, runNumber, trig2, globalEfficiencies);
  if (!trig2)
    return globalEfficiency(leptons, runNumber, trig1, globalEfficiencies);
  globalEfficiencies = {1.};
  bool success = true;
  for (auto& lepton : leptons) {
    std::size_t leg;
    if (trig1.relevantFor(lepton))
      leg = trig1();
    else if (trig2.relevantFor(lepton))
      leg = trig2();
    else
      continue;
    if (!aboveThreshold(lepton, leg))
      continue;
    auto efficiencies =
        getCachedTriggerLegEfficiencies(lepton, runNumber, leg, success);
    globalEfficiencies *= ~efficiencies;
  }
  globalEfficiencies = ~globalEfficiencies;
  return success;
}
 
template <typename Trig1L>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const flat_set<Trig1L>& trigs,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig1L::is1L(), bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Several1L() at line "
                << __LINE__);
  if (trigs.size() == 1)
    return globalEfficiency(leptons, runNumber, *trigs.cbegin(),
                            globalEfficiencies);
  if (!trigs.size()) {
    globalEfficiencies = {0.};
    return true;
  }
  globalEfficiencies = {1.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (Trig1L::irrelevantFor(lepton))
      continue;
    std::size_t loosestLeg =
        getLoosestLegAboveThreshold(lepton, trigs, success);
    if (loosestLeg && success) {
      auto efficiencies = getCachedTriggerLegEfficiencies(lepton, runNumber,
                                                          loosestLeg, success);
      globalEfficiencies *= ~efficiencies;
    }
  }
  globalEfficiencies = ~globalEfficiencies;
  return success;
}
 
template <typename Trig1L_obj1, typename Trig1L_obj2>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const flat_set<Trig1L_obj1>& trigs1,
                                  const flat_set<Trig1L_obj2>& trigs2,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig1L_obj1::is1L() && Trig1L_obj2::is1L() &&
                            Trig1L_obj1::object() != Trig1L_obj2::object(),
                        bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Several1L() at line "
                << __LINE__);
  if (trigs1.size() == 1 && trigs2.size() == 1) {
    return globalEfficiency(leptons, runNumber, *trigs1.cbegin(),
                            *trigs2.cbegin(), globalEfficiencies);
  }
  if (!trigs1.size())
    return globalEfficiency(leptons, runNumber, trigs2, globalEfficiencies);
  if (!trigs2.size())
    return globalEfficiency(leptons, runNumber, trigs1, globalEfficiencies);
  globalEfficiencies = {1.};
  bool success = true;
  for (auto& lepton : leptons) {
    std::size_t loosestLeg;
    if (Trig1L_obj1::relevantFor(lepton))
      loosestLeg = getLoosestLegAboveThreshold(lepton, trigs1, success);
    else if (Trig1L_obj2::relevantFor(lepton))
      loosestLeg = getLoosestLegAboveThreshold(lepton, trigs2, success);
    else
      continue;
    if (loosestLeg && success) {
      auto efficiencies = getCachedTriggerLegEfficiencies(lepton, runNumber,
                                                          loosestLeg, success);
      globalEfficiencies *= ~efficiencies;
    }
  }
  globalEfficiencies = ~globalEfficiencies;
  return success;
}
 
template <typename Trig2Lmix>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig2Lmix trig,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig2Lmix::is2Lmix(), bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2L() at line "
                << __LINE__);
  Efficiencies efficiencies[2];
  bool success =
      globalEfficiency(leptons, runNumber, trig.side1(), efficiencies[0]) &&
      globalEfficiency(leptons, runNumber, trig.side2(), efficiencies[1]);
  if (success)
    globalEfficiencies = efficiencies[0] * efficiencies[1];
  else
    globalEfficiencies = {0.};
  return success;
}
 
template <typename Trig2Lsym>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig2Lsym trig,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig2Lsym::is2Lsym(), bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2L() at line "
                << __LINE__);
  globalEfficiencies = {0.};
  if (!trig)
    return true;
  Efficiencies singleInefficiencies(1.);
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig.irrelevantFor(lepton) || !aboveThreshold(lepton, trig()))
      continue;
    auto efficiencies =
        getCachedTriggerLegEfficiencies(lepton, runNumber, trig(), success);
    globalEfficiencies = ~efficiencies * globalEfficiencies +
                         efficiencies * ~singleInefficiencies;
    singleInefficiencies *= ~efficiencies;
  }
  return success;
}
 
template <typename Trig2Lasym>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig2Lasym trig,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig2Lasym::is2Lasym(), bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2L() at line "
                << __LINE__);
  if (trig.symmetric())
    return globalEfficiency(leptons, runNumber, trig.to_symmetric(),
                            globalEfficiencies);
  globalEfficiencies = {0.};
  if (!trig)
    return true;
  Efficiencies singleInefficiencies[2] = {{1.}, {1.}},
               twoSingleInefficiencies = {1.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig.irrelevantFor(lepton))
      continue;
    Efficiencies efficiencies[2] = {{0.}, {0.}};
    int loosest = 0;
    if (aboveThreshold(lepton, trig(0))) {
      efficiencies[0] =
          getCachedTriggerLegEfficiencies(lepton, runNumber, trig(0), success);
      if (aboveThreshold(lepton, trig(1))) {
        efficiencies[1] = getCachedTriggerLegEfficiencies(lepton, runNumber,
                                                          trig(1), success);
        loosest = m_parent->getLoosestLeg(lepton, trig(0), trig(1), success) ==
                  trig(1);
      }
    } else if (aboveThreshold(lepton, trig(1))) {
      efficiencies[1] =
          getCachedTriggerLegEfficiencies(lepton, runNumber, trig(1), success);
      loosest = 1;
    } else
      continue;
    const int tightest = 1 - loosest;
    globalEfficiencies = ~efficiencies[loosest] * globalEfficiencies +
                         (efficiencies[loosest] - efficiencies[tightest]) *
                             ~singleInefficiencies[tightest] +
                         efficiencies[tightest] * ~twoSingleInefficiencies;
    twoSingleInefficiencies *= ~efficiencies[loosest];
    for (int i = 0; i < 2; ++i)
      singleInefficiencies[i] *= ~efficiencies[i];
  }
  return success;
}
 
template <typename Trig2Lmix, typename Trig1L_obj1, typename Trig1L_obj2>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig2Lmix trig2Lmix,
                                  const flat_set<Trig1L_obj1>& trigs1L1,
                                  const flat_set<Trig1L_obj2>& trigs1L2,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig2Lmix::is2Lmix() && Trig1L_obj1::is1L() &&
                            Trig2Lmix::object1() == Trig1L_obj1::object() &&
                            Trig1L_obj2::is1L() &&
                            Trig2Lmix::object2() == Trig1L_obj2::object(),
                        bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2LSeveral1L() at line "
                << __LINE__);
  if (!(trigs1L1.size() + trigs1L2.size()))
    return globalEfficiency(leptons, runNumber, trig2Lmix, globalEfficiencies);
  if (trig2Lmix.hiddenBy(trigs1L1) || trig2Lmix.hiddenBy(trigs1L2))
    return globalEfficiency(leptons, runNumber, trigs1L1, trigs1L2,
                            globalEfficiencies);
  Efficiencies efficiencies[4];
  bool success =
      globalEfficiency(leptons, runNumber, trigs1L1, efficiencies[0]) &&
      globalEfficiency(leptons, runNumber, trigs1L2, efficiencies[1]) &&
      globalEfficiency(leptons, runNumber, trig2Lmix.addTo(trigs1L1),
                       efficiencies[2]) &&
      globalEfficiency(leptons, runNumber, trig2Lmix.addTo(trigs1L2),
                       efficiencies[3]);
  if (success) {
    globalEfficiencies = Efficiencies(1.) -
                         ~efficiencies[0] * ~efficiencies[1] +
                         (efficiencies[2] - efficiencies[0]) *
                             (efficiencies[3] - efficiencies[1]);
  } else
    globalEfficiencies = {0.};
  return success;
}
 
template <typename Trig2L, typename Trig1L>
inline auto Calculator::globalEfficiency(const LeptonList& leptons,
                                         unsigned runNumber,
                                         const Trig2L trig2L,
                                         const Trig1L trig1L,
                                         Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig2L::is2Lnomix() && Trig1L::is1L() &&
                            Trig2L::object() == Trig1L::object(),
                        bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2LSeveral1L() at line "
                << __LINE__);
  return globalEfficiency(leptons, runNumber, trig2L, flat_set<Trig1L>{trig1L},
                          globalEfficiencies);
}
 
template <typename Trig2Lsym, typename Trig1L>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig2Lsym trig2L,
                                  const flat_set<Trig1L>& trigs1L,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig2Lsym::is2Lsym() && Trig1L::is1L() &&
                            Trig1L::object() == Trig2Lsym::object(),
                        bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2LSeveral1L() at line "
                << __LINE__);
  if (!trigs1L.size())
    return globalEfficiency(leptons, runNumber, trig2L, globalEfficiencies);
  if (!trig2L || trig2L.hiddenBy(trigs1L))
    return globalEfficiency(leptons, runNumber, trigs1L, globalEfficiencies);
  globalEfficiencies = {0.};
  Efficiencies twoSingleInefficiencies = {1.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig2L.irrelevantFor(lepton))
      continue;
    Efficiencies efficiencies1L(0.), efficiencies2L(0.);
    const Efficiencies* loosestLegEfficiency;
    std::size_t loosest1lepLeg =
        getLoosestLegAboveThreshold(lepton, trigs1L, success);
    if (loosest1lepLeg) {
      efficiencies1L = getCachedTriggerLegEfficiencies(lepton, runNumber,
                                                       loosest1lepLeg, success);
      if (aboveThreshold(lepton, trig2L())) {
        efficiencies2L = getCachedTriggerLegEfficiencies(lepton, runNumber,
                                                         trig2L(), success);
        loosestLegEfficiency =
            (m_parent->getLoosestLeg(lepton, trig2L(), loosest1lepLeg,
                                     success) == trig2L())
                ? &efficiencies2L
                : &efficiencies1L;
      } else
        loosestLegEfficiency = &efficiencies1L;
    } else if (aboveThreshold(lepton, trig2L())) {
      efficiencies2L =
          getCachedTriggerLegEfficiencies(lepton, runNumber, trig2L(), success);
      loosestLegEfficiency = &efficiencies2L;
    } else
      continue;
    globalEfficiencies =
        ~(*loosestLegEfficiency) * globalEfficiencies + efficiencies1L;
    if (loosestLegEfficiency == &efficiencies2L)
      globalEfficiencies +=
          ~twoSingleInefficiencies * (efficiencies2L - efficiencies1L);
    twoSingleInefficiencies *= ~(*loosestLegEfficiency);
  }
  return success;
}
 
template <typename Trig2Lasym, typename Trig1L>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig2Lasym trig2L,
                                  const flat_set<Trig1L>& trigs1L,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig2Lasym::is2Lasym() && Trig1L::is1L() &&
                            Trig1L::object() == Trig2Lasym::object(),
                        bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2LSeveral1L() at line "
                << __LINE__);
  if (trig2L.symmetric())
    return globalEfficiency(leptons, runNumber, trig2L.to_symmetric(), trigs1L,
                            globalEfficiencies);
  if (!trigs1L.size())
    return globalEfficiency(leptons, runNumber, trig2L, globalEfficiencies);
  if (!trig2L || trig2L.hiddenBy(trigs1L))
    return globalEfficiency(leptons, runNumber, trigs1L, globalEfficiencies);
  globalEfficiencies = {0.};
  Efficiencies twoSingleInefficiencies[2] = {{1.}, {1.}},
               threeSingleInefficiencies = {1.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig2L.irrelevantFor(lepton))
      continue;
    flat_set<std::size_t> validLegs;
    for (std::size_t leg : trig2L.legs)
      if (aboveThreshold(lepton, leg))
        validLegs.insert(leg);
    Efficiencies efficiencies1L = {0.};
    std::size_t loosest1lepLeg =
        getLoosestLegAboveThreshold(lepton, trigs1L, success);
    if (loosest1lepLeg) {
      efficiencies1L = getCachedTriggerLegEfficiencies(lepton, runNumber,
                                                       loosest1lepLeg, success);
      validLegs.insert(loosest1lepLeg);
    }
    if (!validLegs.size())
      continue;
    auto looseLegs = m_parent->getTwoLoosestLegs(lepton, validLegs, success);
    auto efficienciesLoose =
        (looseLegs.first == loosest1lepLeg)
            ? efficiencies1L
            : getCachedTriggerLegEfficiencies(lepton, runNumber,
                                              looseLegs.first, success);
    Efficiencies efficienciesMedium = {0.};
    if (validLegs.size() >= 2)
      efficienciesMedium =
          (looseLegs.second == loosest1lepLeg)
              ? efficiencies1L
              : getCachedTriggerLegEfficiencies(lepton, runNumber,
                                                looseLegs.second, success);
    globalEfficiencies =
        ~efficienciesLoose * globalEfficiencies + efficiencies1L;
    if (loosest1lepLeg != looseLegs.first) {
      globalEfficiencies +=
          (efficienciesLoose - efficienciesMedium) *
          ~twoSingleInefficiencies[looseLegs.first == trig2L.legs[0]];
      if (loosest1lepLeg != looseLegs.second)
        globalEfficiencies +=
            (efficienciesMedium - efficiencies1L) * ~threeSingleInefficiencies;
    }
    threeSingleInefficiencies *= ~efficienciesLoose;
    twoSingleInefficiencies[0] *= (looseLegs.first != trig2L.legs[1])
                                      ? ~efficienciesLoose
                                      : ~efficienciesMedium;  
    twoSingleInefficiencies[1] *= (looseLegs.first != trig2L.legs[0])
                                      ? ~efficienciesLoose
                                      : ~efficienciesMedium;  
  }
  return success;
}
 
template <typename Trig2Lsym, typename Trig1L>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig2Lsym trig2L1,
                                  const Trig2Lsym trig2L2,
                                  const flat_set<Trig1L>& trigs1L,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig2Lsym::is2Lsym() && Trig1L::is1L() &&
                            Trig1L::object() == Trig2Lsym::object(),
                        bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two2LSeveral1L() at line "
                << __LINE__);
  if (!trig2L1 || trig2L1 == trig2L2 || trig2L1.hiddenBy(trigs1L))
    return globalEfficiency(leptons, runNumber, trig2L2, trigs1L,
                            globalEfficiencies);
  if (!trig2L2 || trig2L2.hiddenBy(trigs1L))
    return globalEfficiency(leptons, runNumber, trig2L1, trigs1L,
                            globalEfficiencies);
  globalEfficiencies = {0.};
  Efficiencies singleInefficiencies{1.};
  Efficiencies efficiencies2Lsym[2] = {{0.}, {0.}};
 
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig2L1.irrelevantFor(lepton))
      continue;
    flat_set<std::size_t> validLegs;
    std::map<std::size_t, Efficiencies> efficiencies{{0, 0.}};
    std::size_t loosest1lepLeg =
        getLoosestLegAboveThreshold(lepton, trigs1L, success);
    for (std::size_t leg : {loosest1lepLeg, trig2L1(), trig2L2()}) {
      if (leg && aboveThreshold(lepton, leg)) {
        validLegs.insert(leg);
        efficiencies.emplace(leg, getCachedTriggerLegEfficiencies(
                                      lepton, runNumber, leg, success));
      } else
        efficiencies.emplace(leg, 0.);
    }
    if (!validLegs.size())
      continue;
    auto looseLegs = m_parent->getTwoLoosestLegs(lepton, validLegs, success);
    std::size_t lambda13 =
        (looseLegs.first != trig2L2()) ? looseLegs.first : looseLegs.second;
    std::size_t lambda23 =
        (looseLegs.first != trig2L1()) ? looseLegs.first : looseLegs.second;
    globalEfficiencies = globalEfficiencies * ~efficiencies[looseLegs.first] +
                         efficiencies[loosest1lepLeg];
    if (looseLegs.first == trig2L1())
      globalEfficiencies +=
          efficiencies2Lsym[1] *
          (efficiencies[trig2L1()] - efficiencies[looseLegs.second]);
    if (looseLegs.first == trig2L2())
      globalEfficiencies +=
          efficiencies2Lsym[0] *
          (efficiencies[trig2L2()] - efficiencies[looseLegs.second]);
    if (looseLegs.first != loosest1lepLeg)
      globalEfficiencies +=
          ~singleInefficiencies *
          (efficiencies[looseLegs.second] - efficiencies[loosest1lepLeg]);
    efficiencies2Lsym[0] =
        ~efficiencies[looseLegs.first] * efficiencies2Lsym[0] +
        efficiencies[lambda23];
    efficiencies2Lsym[1] =
        ~efficiencies[looseLegs.first] * efficiencies2Lsym[1] +
        efficiencies[lambda13];
    if (looseLegs.first == trig2L1())
      efficiencies2Lsym[0] +=
          (efficiencies[trig2L1()] - efficiencies[lambda23]) *
          ~singleInefficiencies;
    if (looseLegs.first == trig2L2())
      efficiencies2Lsym[1] +=
          (efficiencies[trig2L2()] - efficiencies[lambda13]) *
          ~singleInefficiencies;
    singleInefficiencies *= ~efficiencies[looseLegs.first];
  }
  return success;
}
 
template <typename Trig2Lasym, typename Trig2Lsym, typename Trig1L>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig2Lasym trig2Lasym,
                                  const Trig2Lsym trig2Lsym,
                                  const flat_set<Trig1L>& trigs1L,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig2Lasym::is2Lasym() && Trig2Lsym::is2Lsym() &&
                            Trig2Lsym::object() == Trig2Lasym::object() &&
                            Trig1L::is1L() &&
                            Trig1L::object() == Trig2Lasym::object(),
                        bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two2LSeveral1L() at line "
                << __LINE__);
  if (!trig2Lasym || trig2Lasym.hiddenBy(trigs1L))
    return globalEfficiency(leptons, runNumber, trig2Lsym, trigs1L,
                            globalEfficiencies);
  if (!trig2Lsym || trig2Lsym.hiddenBy(trigs1L))
    return globalEfficiency(leptons, runNumber, trig2Lasym, trigs1L,
                            globalEfficiencies);
  if (trig2Lasym(0) == trig2Lsym() || trig2Lasym(1) == trig2Lsym()) {
    ATH_MSG_ERROR(
        "implementation -- does this function work properly when the two 2L "
        "triggers have one leg in common? Must be checked");
    return false;
  }
  if (trig2Lasym.symmetric())
    return globalEfficiency(leptons, runNumber, trig2Lasym.to_symmetric(),
                            trig2Lsym, trigs1L, globalEfficiencies);
  globalEfficiencies = {0.};
  Efficiencies singleInefficiencies[3] = {{1.}, {1.}, {1.}};
  Efficiencies efficiencies2Lasym{0.},
      efficiencies2Lsym[3] = {{0.}, {0.}, {0.}};
 
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig2Lasym.irrelevantFor(lepton))
      continue;
    flat_set<std::size_t> validLegs;
    std::map<std::size_t, Efficiencies> efficiencies{{0, 0.}};
    std::size_t loosest1lepLeg =
        getLoosestLegAboveThreshold(lepton, trigs1L, success);
    for (std::size_t leg :
         {trig2Lasym(0), trig2Lasym(1), trig2Lsym(), loosest1lepLeg}) {
      if (leg && aboveThreshold(lepton, leg)) {
        validLegs.insert(leg);
        efficiencies.emplace(leg, getCachedTriggerLegEfficiencies(
                                      lepton, runNumber, leg, success));
      } else
        efficiencies.emplace(leg, 0.);
    }
    if (!validLegs.size())
      continue;
 
    const auto sortedLegs = m_parent->getSortedLegs(lepton, validLegs, success);
    if (!success)
      return false;
    std::size_t loosestLeg = sortedLegs[0];
    std::size_t secondLoosestLeg = validLegs.size() >= 2 ? sortedLegs[1] : 0;
    std::size_t secondTightestLeg = validLegs.size() >= 3 ? sortedLegs[2] : 0;
    std::size_t tightestLeg = validLegs.size() >= 4 ? sortedLegs[3] : 0;
    std::size_t lambda124 =
        (loosestLeg != trig2Lasym(1)) ? loosestLeg : secondLoosestLeg;
    std::size_t lambda134 =
        (loosestLeg != trig2Lasym(0)) ? loosestLeg : secondLoosestLeg;
    std::size_t lambda234 =
        (loosestLeg != trig2Lsym()) ? loosestLeg : secondLoosestLeg;
    std::size_t lambda14 = (lambda124 != trig2Lasym(0))   ? lambda124
                           : (lambda134 != trig2Lasym(1)) ? lambda134
                                                          : secondTightestLeg;
    std::size_t lambda24 = (lambda124 != trig2Lsym())     ? lambda124
                           : (lambda234 != trig2Lasym(1)) ? lambda234
                                                          : secondTightestLeg;
    std::size_t lambda34 = (lambda134 != trig2Lsym())     ? lambda134
                           : (lambda234 != trig2Lasym(0)) ? lambda234
                                                          : secondTightestLeg;
    std::size_t tau13 = 0, tau12 = 0, tau23 = 0;
    if (loosestLeg == trig2Lsym() || loosestLeg == trig2Lasym(0))
      tau12 = (loosestLeg == trig2Lsym()) ? trig2Lasym(0) : trig2Lsym();
    else if (secondLoosestLeg == trig2Lsym() ||
             secondLoosestLeg == trig2Lasym(0))
      tau12 = (secondLoosestLeg == trig2Lsym()) ? trig2Lasym(0) : trig2Lsym();
    else if (secondTightestLeg == trig2Lsym() ||
             secondTightestLeg == trig2Lasym(0))
      tau12 = (secondTightestLeg == trig2Lsym()) ? trig2Lasym(0) : trig2Lsym();
    else if (tightestLeg == trig2Lsym() || tightestLeg == trig2Lasym(0))
      tau12 = (tightestLeg == trig2Lsym()) ? trig2Lasym(0) : trig2Lsym();
    if (loosestLeg == trig2Lsym() || loosestLeg == trig2Lasym(1))
      tau13 = (loosestLeg == trig2Lsym()) ? trig2Lasym(1) : trig2Lsym();
    else if (secondLoosestLeg == trig2Lsym() ||
             secondLoosestLeg == trig2Lasym(1))
      tau13 = (secondLoosestLeg == trig2Lsym()) ? trig2Lasym(1) : trig2Lsym();
    else if (secondTightestLeg == trig2Lsym() ||
             secondTightestLeg == trig2Lasym(1))
      tau13 = (secondTightestLeg == trig2Lsym()) ? trig2Lasym(1) : trig2Lsym();
    else if (tightestLeg == trig2Lsym() || tightestLeg == trig2Lasym(1))
      tau13 = (tightestLeg == trig2Lsym()) ? trig2Lasym(1) : trig2Lsym();
    if (loosestLeg == trig2Lasym(0) || loosestLeg == trig2Lasym(1))
      tau23 = (loosestLeg == trig2Lasym(0)) ? trig2Lasym(1) : trig2Lasym(0);
    else if (secondLoosestLeg == trig2Lasym(0) ||
             secondLoosestLeg == trig2Lasym(1))
      tau23 =
          (secondLoosestLeg == trig2Lasym(0)) ? trig2Lasym(1) : trig2Lasym(0);
    else if (secondTightestLeg == trig2Lasym(0) ||
             secondTightestLeg == trig2Lasym(1))
      tau23 =
          (secondTightestLeg == trig2Lasym(0)) ? trig2Lasym(1) : trig2Lasym(0);
    else if (tightestLeg == trig2Lasym(0) || tightestLeg == trig2Lasym(1))
      tau23 = (tightestLeg == trig2Lasym(0)) ? trig2Lasym(1) : trig2Lasym(0);
 
    globalEfficiencies =
        globalEfficiencies * ~efficiencies[loosestLeg] +
        efficiencies[loosest1lepLeg] +
        (efficiencies[tau13] - efficiencies[secondTightestLeg]) *
            ~singleInefficiencies[0] +
        (efficiencies[tau12] - efficiencies[secondTightestLeg]) *
            ~singleInefficiencies[1] +
        (efficiencies[tau23] - efficiencies[secondTightestLeg]) *
            efficiencies2Lsym[2];
    if (loosestLeg == trig2Lsym())
      globalEfficiencies +=
          (efficiencies[trig2Lsym()] - efficiencies[secondLoosestLeg]) *
          efficiencies2Lasym;
    else if (loosestLeg == trig2Lasym(1))
      globalEfficiencies +=
          (efficiencies[trig2Lasym(1)] - efficiencies[secondLoosestLeg]) *
          efficiencies2Lsym[0];
    else if (loosestLeg == trig2Lasym(0))
      globalEfficiencies +=
          (efficiencies[trig2Lasym(0)] - efficiencies[secondLoosestLeg]) *
          efficiencies2Lsym[1];
    if (secondTightestLeg &&
        tightestLeg == loosest1lepLeg)  
      globalEfficiencies +=
          (efficiencies[secondTightestLeg] - efficiencies[tightestLeg]) *
          ~singleInefficiencies[2];
 
    efficiencies2Lasym =
        ~efficiencies[loosestLeg] * efficiencies2Lasym + efficiencies[lambda14];
    if (loosestLeg == trig2Lasym(0) || loosestLeg == trig2Lasym(1)) {
      efficiencies2Lasym +=
          (efficiencies[loosestLeg] - efficiencies[secondLoosestLeg]) *
              ~singleInefficiencies[loosestLeg == trig2Lasym(0)] +
          (efficiencies[secondLoosestLeg] - efficiencies[lambda14]) *
              ~singleInefficiencies[2];
    }
    efficiencies2Lsym[0] = ~efficiencies[lambda124] * efficiencies2Lsym[0] +
                           efficiencies[lambda24];
    efficiencies2Lsym[1] = ~efficiencies[lambda134] * efficiencies2Lsym[1] +
                           efficiencies[lambda34];
    efficiencies2Lsym[2] = ~efficiencies[loosestLeg] * efficiencies2Lsym[2] +
                           efficiencies[lambda234];
    if (lambda124 == trig2Lsym())
      efficiencies2Lsym[0] +=
          (efficiencies[trig2Lsym()] - efficiencies[lambda24]) *
          ~singleInefficiencies[0];
    if (lambda134 == trig2Lsym())
      efficiencies2Lsym[1] +=
          (efficiencies[trig2Lsym()] - efficiencies[lambda34]) *
          ~singleInefficiencies[1];
    if (loosestLeg == trig2Lsym())
      efficiencies2Lsym[2] +=
          (efficiencies[trig2Lsym()] - efficiencies[lambda234]) *
          ~singleInefficiencies[2];
    singleInefficiencies[0] *= ~efficiencies[lambda124];
    singleInefficiencies[1] *= ~efficiencies[lambda134];
    singleInefficiencies[2] *= ~efficiencies[loosestLeg];
  }
  return success;
}
 
template <typename Trig3Lsym>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig3Lsym trig,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig3Lsym::is3Lsym(), bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One3L() at line "
                << __LINE__);
  globalEfficiencies = {0.};
  Efficiencies singleInefficiencies{1.}, efficiencies2L{0.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig.irrelevantFor(lepton) || !aboveThreshold(lepton, trig()))
      continue;
    auto efficiencies =
        getCachedTriggerLegEfficiencies(lepton, runNumber, trig(), success);
    globalEfficiencies =
        ~efficiencies * globalEfficiencies + efficiencies * efficiencies2L;
    efficiencies2L =
        ~efficiencies * efficiencies2L + efficiencies * ~singleInefficiencies;
    singleInefficiencies *= ~efficiencies;
  }
  return success;
}
 
template <typename Trig3Lhalfsym>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig3Lhalfsym trig,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig3Lhalfsym::is3Lhalfsym(), bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One3L() at line "
                << __LINE__);
  if (trig.symmetric())
    return globalEfficiency(leptons, runNumber, trig.to_symmetric(),
                            globalEfficiencies);
  globalEfficiencies = {0.};
  Efficiencies singleInefficiencies[2] = {{1.}, {1.}},
               twoSingleInefficiencies{1.};
  Efficiencies efficiencies2Lsym{0.}, efficiencies2Lasym{0.},
      efficiencies2L2L{0.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig.irrelevantFor(lepton))
      continue;
    Efficiencies efficiencies[2] = {{0.}, {0.}};
    const int asym = 0, sym = 1;
    int loosestLeg;
    if (aboveThreshold(lepton, trig.asymLeg())) {
      efficiencies[asym] = getCachedTriggerLegEfficiencies(
          lepton, runNumber, trig.asymLeg(), success);
      if (aboveThreshold(lepton, trig.symLeg())) {
        efficiencies[sym] = getCachedTriggerLegEfficiencies(
            lepton, runNumber, trig.symLeg(), success);
        loosestLeg =
            m_parent->getLoosestLeg(lepton, trig.asymLeg(), trig.symLeg(),
                                    success) == trig.asymLeg()
                ? asym
                : sym;
      } else
        loosestLeg = asym;
    } else if (aboveThreshold(lepton, trig.symLeg())) {
      efficiencies[sym] = getCachedTriggerLegEfficiencies(
          lepton, runNumber, trig.symLeg(), success);
      loosestLeg = sym;
    } else
      continue;
    Efficiencies delta = efficiencies[asym] - efficiencies[sym];
    if (loosestLeg == asym) {
      globalEfficiencies = ~efficiencies[asym] * globalEfficiencies +
                           efficiencies[sym] * efficiencies2L2L +
                           delta * efficiencies2Lsym;
      efficiencies2L2L = ~efficiencies[asym] * efficiencies2L2L +
                         efficiencies[sym] * ~twoSingleInefficiencies +
                         delta * ~singleInefficiencies[sym];
      efficiencies2Lasym = ~efficiencies[asym] * efficiencies2Lasym +
                           efficiencies[sym] * ~twoSingleInefficiencies +
                           delta * ~singleInefficiencies[sym];
    } else {
      globalEfficiencies = ~efficiencies[sym] * globalEfficiencies +
                           efficiencies[asym] * efficiencies2L2L -
                           delta * efficiencies2Lasym;
      efficiencies2L2L = ~efficiencies[sym] * efficiencies2L2L +
                         efficiencies[sym] * ~twoSingleInefficiencies;
      efficiencies2Lasym = ~efficiencies[sym] * efficiencies2Lasym +
                           efficiencies[asym] * ~twoSingleInefficiencies -
                           delta * ~singleInefficiencies[asym];
    }
    efficiencies2Lsym = ~efficiencies[sym] * efficiencies2Lsym +
                        efficiencies[sym] * ~singleInefficiencies[sym];
    twoSingleInefficiencies *= ~efficiencies[loosestLeg];
    singleInefficiencies[sym] *= ~efficiencies[sym];
    singleInefficiencies[asym] *= ~efficiencies[asym];
  }
  return success;
}
 
template <typename Trig2L, typename Trig2Lmix>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig2L trig2L,
                                  const Trig2Lmix trig2Lmix,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig2L::is2Lnomix() && Trig2Lmix::is2Lmix() &&
                            (Trig2Lmix::object1() == Trig2L::object() ||
                             Trig2Lmix::object2() == Trig2L::object()),
                        bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two2L() at line "
                << __LINE__);
  Efficiencies efficiencies1L, efficiencies2L, efficiencies2Lor1L;
  bool success =
      globalEfficiency(leptons, runNumber,
                       trig2Lmix.template antiside<Trig2L>(), efficiencies1L);
  success =
      success && globalEfficiency(leptons, runNumber, trig2L, efficiencies2L);
  success = success && globalEfficiency(leptons, runNumber, trig2L,
                                        trig2Lmix.template side<Trig2L>(),
                                        efficiencies2Lor1L);
  globalEfficiencies =
      efficiencies2L * ~efficiencies1L + efficiencies1L * efficiencies2Lor1L;
  return success;
}
 
template <typename Trig2L_obj1, typename Trig2L_obj2, typename Trig2Lmix>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig2L_obj1 trig2L_obj1,
                                  const Trig2L_obj2 trig2L_obj2,
                                  const Trig2Lmix trig2Lmix,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig2Lmix::is2Lmix() && Trig2L_obj1::is2Lnomix() &&
                            Trig2L_obj1::object() == Trig2Lmix::object1() &&
                            Trig2L_obj2::is2Lnomix() &&
                            Trig2L_obj2::object() == Trig2Lmix::object2(),
 
                        bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Three2L() at line "
                << __LINE__);
  Efficiencies efficiencies2L[2] = {{0.}, {0.}},
               efficiencies2Lor1L[2] = {{0.}, {0.}};
  bool success = true;
  if (trig2L_obj1) {
    success = success && globalEfficiency(leptons, runNumber, trig2L_obj1,
                                          efficiencies2L[0]);
    if (trig2Lmix)
      success =
          success && globalEfficiency(leptons, runNumber, trig2L_obj1,
                                      trig2Lmix.template side<Trig2L_obj1>(),
                                      efficiencies2Lor1L[0]);
    else
      efficiencies2Lor1L[0] = efficiencies2L[0];
  } else if (trig2Lmix)
    success =
        success && globalEfficiency(leptons, runNumber,
                                    trig2Lmix.template side<Trig2L_obj1>(),
                                    efficiencies2Lor1L[0]);
  if (trig2L_obj2) {
    success = success && globalEfficiency(leptons, runNumber, trig2L_obj2,
                                          efficiencies2L[1]);
    if (trig2Lmix)
      success =
          success && globalEfficiency(leptons, runNumber, trig2L_obj2,
                                      trig2Lmix.template side<Trig2L_obj2>(),
                                      efficiencies2Lor1L[1]);
    else
      efficiencies2Lor1L[1] = efficiencies2L[1];
  } else if (trig2Lmix)
    success =
        success && globalEfficiency(leptons, runNumber,
                                    trig2Lmix.template side<Trig2L_obj2>(),
                                    efficiencies2Lor1L[1]);
  globalEfficiencies = efficiencies2L[0] * ~efficiencies2Lor1L[1] +
                       efficiencies2L[1] * ~efficiencies2Lor1L[0] +
                       efficiencies2Lor1L[0] * efficiencies2Lor1L[1];
  return success;
}
 
template <typename Trig2L_obj1, typename Trig2L_obj2, typename Trig2Lmix,
          typename Trig1L_obj1, typename Trig1L_obj2>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig2L_obj1 trig2L_obj1,
                                  const Trig2L_obj2 trig2L_obj2,
                                  const Trig2Lmix trig2Lmix,
                                  const flat_set<Trig1L_obj1>& trigs1L_obj1,
                                  const flat_set<Trig1L_obj2>& trigs1L_obj2,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig2Lmix::is2Lmix() && Trig2L_obj1::is2Lnomix() &&
                            Trig2L_obj1::object() == Trig2Lmix::object1() &&
                            Trig2L_obj2::is2Lnomix() &&
                            Trig2L_obj2::object() == Trig2Lmix::object2() &&
                            Trig1L_obj1::is1L() &&
                            Trig1L_obj1::object() == Trig2Lmix::object1() &&
                            Trig1L_obj2::is1L() &&
                            Trig1L_obj2::object() == Trig2Lmix::object2(),
 
                        bool> {
  ATH_MSG_DEBUG(
      "Entered Calculator::globalEfficiency_Three2LSeveral1L() at line "
      << __LINE__);
  Efficiencies efficiencies[4];
  bool success = true;
  if (trig2L_obj1)
    success = success && globalEfficiency(leptons, runNumber, trig2L_obj1,
                                          trigs1L_obj1, efficiencies[0]);
  else
    success = success && globalEfficiency(leptons, runNumber, trigs1L_obj1,
                                          efficiencies[0]);
  if (trig2L_obj2)
    success = success && globalEfficiency(leptons, runNumber, trig2L_obj2,
                                          trigs1L_obj2, efficiencies[1]);
  else
    success = success && globalEfficiency(leptons, runNumber, trigs1L_obj2,
                                          efficiencies[1]);
  if (trig2Lmix && !trig2Lmix.hiddenBy(trigs1L_obj1)) {
    auto t = trig2Lmix.addTo(trigs1L_obj1);
    if (trig2L_obj1)
      success = success && globalEfficiency(leptons, runNumber, trig2L_obj1, t,
                                            efficiencies[2]);
    else
      success =
          success && globalEfficiency(leptons, runNumber, t, efficiencies[2]);
  } else
    efficiencies[2] = efficiencies[0];
  if (trig2Lmix && !trig2Lmix.hiddenBy(trigs1L_obj2)) {
    auto t = trig2Lmix.addTo(trigs1L_obj2);
    if (trig2L_obj2)
      success = success && globalEfficiency(leptons, runNumber, trig2L_obj2, t,
                                            efficiencies[3]);
    else
      success =
          success && globalEfficiency(leptons, runNumber, t, efficiencies[3]);
  } else
    efficiencies[3] = efficiencies[1];
  globalEfficiencies =
      Efficiencies(1.) - ~efficiencies[0] * ~efficiencies[1] +
      (efficiencies[2] - efficiencies[0]) * (efficiencies[3] - efficiencies[1]);
  return success;
}
 
template <typename Trig2L_obj1, typename Trig2Lsym_obj1, typename Trig2L_obj2,
          typename Trig2Lsym_obj2, typename Trig2Lmix, typename Trig1L_obj1,
          typename Trig1L_obj2>
auto Calculator::globalEfficiency(
    const LeptonList& leptons, unsigned runNumber,
    const Trig2L_obj1 trig2L_obj1, const Trig2Lsym_obj1 trig2Lsym_obj1,
    const Trig2L_obj2 trig2L_obj2, const Trig2Lsym_obj2 trig2Lsym_obj2,
    const Trig2Lmix trig2Lmix1, const Trig2Lmix trig2Lmix2,
    const flat_set<Trig1L_obj1>& trigs1L_obj1,
    const flat_set<Trig1L_obj2>& trigs1L_obj2, Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig2Lmix::is2Lmix() && Trig2L_obj1::is2Lnomix() &&
                            Trig2L_obj1::object() == Trig2Lmix::object1() &&
                            Trig2L_obj2::is2Lnomix() &&
                            Trig2L_obj2::object() == Trig2Lmix::object2() &&
                            Trig2Lsym_obj1::is2Lsym() &&
                            Trig2Lsym_obj1::object() == Trig2Lmix::object1() &&
                            Trig2Lsym_obj2::is2Lsym() &&
                            Trig2Lsym_obj2::object() == Trig2Lmix::object2() &&
                            Trig1L_obj1::is1L() &&
                            Trig1L_obj1::object() == Trig2Lmix::object1() &&
                            Trig1L_obj2::is1L() &&
                            Trig1L_obj2::object() == Trig2Lmix::object2(),
                        bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Six2LSeveral1L() at line "
                << __LINE__);
 
  auto singleObjectFactor = [=](auto trig2L, auto trig2Lsym, auto& trigs1L,
                                Efficiencies(&efficiencies)[4]) -> bool {
    auto eval_for = [=](const auto& trigs1L_extended,
                        Efficiencies& eff) -> bool {
      if (trig2L && trig2Lsym)
        return this->globalEfficiency(leptons, runNumber, trig2L, trig2Lsym,
                                      trigs1L_extended, eff);
      else if (trig2L)
        return this->globalEfficiency(leptons, runNumber, trig2L,
                                      trigs1L_extended, eff);
      else if (trig2Lsym)
        return this->globalEfficiency(leptons, runNumber, trig2Lsym,
                                      trigs1L_extended, eff);
      else
        return this->globalEfficiency(leptons, runNumber, trigs1L_extended,
                                      eff);
    };
 
    bool success = eval_for(trigs1L, efficiencies[0]);
    if (trig2Lmix1)
      success = success && eval_for(trig2Lmix1.addTo(trigs1L), efficiencies[1]);
    else
      efficiencies[1] = efficiencies[0];
    if (trig2Lmix2) {
      auto t = trig2Lmix2.addTo(trigs1L);
      success = success && eval_for(t, efficiencies[2]);
      if (trig2Lmix1)
        success&& eval_for(trig2Lmix1.addTo(t), efficiencies[3]);
      else
        efficiencies[3] = efficiencies[2];
    } else {
      efficiencies[2] = efficiencies[0];
      efficiencies[3] = efficiencies[1];
    }
    return success;
  };
 
  Efficiencies efficiencies1[4], efficiencies2[4];
  bool success = singleObjectFactor(trig2L_obj1, trig2Lsym_obj1, trigs1L_obj1,
                                    efficiencies1) &&
                 singleObjectFactor(trig2L_obj2, trig2Lsym_obj2, trigs1L_obj2,
                                    efficiencies2);
  globalEfficiencies = Efficiencies(1.) -
                       ~efficiencies1[0] * ~efficiencies2[0] +
                       (efficiencies1[1] - efficiencies1[0]) *
                           (efficiencies2[1] - efficiencies2[0]) +
                       (efficiencies1[2] - efficiencies1[0]) *
                           (efficiencies2[2] - efficiencies2[0]) -
                       (efficiencies1[0] - efficiencies1[1] - efficiencies1[2] +
                        efficiencies1[3]) *
                           (efficiencies2[0] - efficiencies2[1] -
                            efficiencies2[2] + efficiencies2[3]);
  return success;
}
 
template <typename Trig3Lmix>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig3Lmix trig,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig3Lmix::is3Lmix(), bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One3L() at line "
                << __LINE__);
  Efficiencies efficiencies[2] = {{0.}, {0.}};
  bool success = globalEfficiency(leptons, runNumber,
                                  trig.template side<Trig3Lmix::object1()>(),
                                  efficiencies[0]) &&
                 globalEfficiency(leptons, runNumber,
                                  trig.template side<Trig3Lmix::object2()>(),
                                  efficiencies[1]);
  globalEfficiencies = efficiencies[0] * efficiencies[1];
  return success;
}
 
template <typename Trig3Lmix1, typename Trig3Lmix2>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig3Lmix1 trig1,
                                  const Trig3Lmix2 trig2,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig3Lmix1::is3Lmix() && Trig3Lmix2::is3Lmix() &&
                            Trig3Lmix1::object1() == Trig3Lmix2::object2() &&
                            Trig3Lmix1::object2() == Trig3Lmix2::object1(),
                        bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two3L() at line "
                << __LINE__);
  Efficiencies efficiencies[6] = {{0.}, {0.}, {0.}, {0.}, {0.}, {0.}};
  auto trig2La = trig1.template side<Trig3Lmix1::object1()>();
  auto trig1La = trig2.template side<Trig3Lmix2::object2()>();
  bool success =
      globalEfficiency(leptons, runNumber, trig1La, efficiencies[0]) &&
      globalEfficiency(leptons, runNumber, trig2La, efficiencies[1]);
  if (!trig2La.hiddenBy(trig1La))
    success = success && globalEfficiency(leptons, runNumber, trig2La, trig1La,
                                          efficiencies[2]);
  else
    efficiencies[2] = efficiencies[0];
  auto trig2Lb = trig2.template side<Trig3Lmix2::object1()>();
  auto trig1Lb = trig1.template side<Trig3Lmix1::object2()>();
  success = success &&
            globalEfficiency(leptons, runNumber, trig1Lb, efficiencies[3]) &&
            globalEfficiency(leptons, runNumber, trig2Lb, efficiencies[4]);
  if (!trig2Lb.hiddenBy(trig1Lb))
    success = success && globalEfficiency(leptons, runNumber, trig2Lb, trig1Lb,
                                          efficiencies[5]);
  else
    efficiencies[5] = efficiencies[3];
  globalEfficiencies =
      efficiencies[0] * efficiencies[4] + efficiencies[3] * efficiencies[1] +
      (efficiencies[2] - efficiencies[0] - efficiencies[1]) *
          (efficiencies[3] + efficiencies[4] - efficiencies[5]);
  return success;
}
 
template <typename Trig4Lsym>
auto Calculator::globalEfficiency(const LeptonList& leptons, unsigned runNumber,
                                  const Trig4Lsym trig,
                                  Efficiencies& globalEfficiencies)
    -> std::enable_if_t<Trig4Lsym::is4Lsym(), bool> {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One4L() at line "
                << __LINE__);
  globalEfficiencies = {0.};
  Efficiencies singleInefficiencies{1.}, efficiencies2L{0.}, efficiencies3L{0.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig.irrelevantFor(lepton) || !aboveThreshold(lepton, trig()))
      continue;
    auto efficiencies =
        getCachedTriggerLegEfficiencies(lepton, runNumber, trig(), success);
    globalEfficiencies =
        ~efficiencies * globalEfficiencies + efficiencies * efficiencies3L;
    efficiencies3L =
        ~efficiencies * efficiencies3L + efficiencies * efficiencies2L;
    efficiencies2L =
        ~efficiencies * efficiencies2L + efficiencies * ~singleInefficiencies;
    singleInefficiencies *= ~efficiencies;
  }
  return success;
}
 
bool Calculator::globalEfficiency_Factorized2(
    const LeptonList& leptons, unsigned runNumber, GlobEffFunc func1,
    GlobEffFunc func2, Efficiencies& globalEfficiencies) {
  Efficiencies efficiencies[2];
  if (!func1(this, leptons, runNumber, efficiencies[0]))
    return false;
  if (!func2(this, leptons, runNumber, efficiencies[1]))
    return false;
  globalEfficiencies = ~(~efficiencies[0] * ~efficiencies[1]);
  return true;
}
 
bool Calculator::globalEfficiency_Factorized3(
    const LeptonList& leptons, unsigned runNumber, GlobEffFunc func1,
    GlobEffFunc func2, GlobEffFunc func3, Efficiencies& globalEfficiencies) {
  Efficiencies efficiencies[3];
  if (!func1(this, leptons, runNumber, efficiencies[0]))
    return false;
  if (!func2(this, leptons, runNumber, efficiencies[1]))
    return false;
  if (!func3(this, leptons, runNumber, efficiencies[2]))
    return false;
  globalEfficiencies =
      ~(~efficiencies[0] * ~efficiencies[1] * ~efficiencies[2]);
  return true;
}
 
bool Calculator::fillListOfLegsFor(const Lepton& lepton,
                                   const std::vector<TrigDef>& triggers,
                                   flat_set<std::size_t>& validLegs) const {
  validLegs.clear();
  for (auto& trig : triggers) {
    TriggerProperties tp(trig);
    if (!tp.valid()) {
      ATH_MSG_ERROR("Unrecognized trigger type " << trig.type);
      return false;
    }
    auto end = tp.cend(lepton.type());
    for (auto itr = tp.cbegin(lepton.type()); itr != end; ++itr)
      if (aboveThreshold(lepton, *itr))
        validLegs.emplace(*itr);
  }
  return true;
}
 
bool Calculator::canTriggerBeFired(
    const TrigDef& trig,
    const std::vector<flat_set<std::size_t>>& firedLegs) const {
  const int nLegs = static_cast<int>(std::count_if(
      trig.leg.begin(), trig.leg.end(), [](auto x) { return x != 0ul; }));
  const int sameLegs = static_cast<int>(
      std::count(trig.leg.begin(), trig.leg.end(), trig.leg[0]));
  if (sameLegs == nLegs) {
    // single-lepton and symmetric multilepton triggers
    return std::count_if(firedLegs.cbegin(), firedLegs.cend(), [&](auto& legs) {
             return legs.count(trig.leg[0]);
           }) >= nLegs;
  } else if (nLegs == 2) {
    // asymmetric or mixed-flavour dilepton triggers
    bool n0 = false, n1 = false;
    for (auto& legs : firedLegs) {
      if (n0 && legs.count(trig.leg[1]))
        return true;
      if (n1 && legs.count(trig.leg[0]))
        return true;
      n0 = n0 || legs.count(trig.leg[0]);
      n1 = n1 || legs.count(trig.leg[1]);
    }
  } else if (nLegs == 3) {
    // other trilepton triggers
    auto end = firedLegs.end();
    for (auto legs0 = firedLegs.begin(); legs0 != end; ++legs0) {
      for (int i = 0; i < 3; ++i) {
        if (!legs0->count(trig.leg[i]))
          continue;
        for (auto legs1 = legs0 + 1; legs1 != end; ++legs1) {
          for (int j = 1; j < 3; ++j) {
            if (!legs1->count(trig.leg[(i + j) % 3]))
              continue;
            for (auto legs2 = legs1 + 1; legs2 != end; ++legs2) {
              if (legs2->count(trig.leg[(i + 3 - j) % 3]))
                return true;
            }
          }
        }
      }
    }
  } else {
    ATH_MSG_ERROR("incomplete support of 4-lepton triggers.");
  }
  return false;
}
 
bool Calculator::globalEfficiency_Toys(const LeptonList& leptons,
                                       unsigned runNumber,
                                       const std::vector<TrigDef>& triggers,
                                       Efficiencies& globalEfficiencies) {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Toys() at line "
                << __LINE__);
  globalEfficiencies = {0.};
  if (m_parent->m_numberOfToys <= 0) {
    ATH_MSG_ERROR("The specified number of toys is <= 0");
    return false;
  }
  std::map<const Lepton*, std::vector<std::pair<std::size_t, Efficiencies>>>
      leptonEfficiencies;
  for (auto& lepton : leptons) {
    flat_set<std::size_t> validLegs;
    if (!fillListOfLegsFor(lepton, triggers, validLegs))
      return false;
    auto& efficiencies = leptonEfficiencies[&lepton];
    const int nLegs = validLegs.size();
    if (nLegs) {
      bool success = true;
      for (std::size_t leg :
           m_parent->getSortedLegs(lepton, validLegs, success)) {
        efficiencies.emplace_back(leg, getCachedTriggerLegEfficiencies(
                                           lepton, runNumber, leg, success));
      }
      if (!success)
        return false;
    }
  }
  unsigned long seed;
  if (!m_parent->m_useInternalSeed) {
    if (!m_parent->retrieveEventNumber(seed)) {
      ATH_MSG_WARNING("Will use internal seed instead of event number");
      seed = m_parent->m_seed++;
    }
  } else
    seed = m_parent->m_seed++;
  std::mt19937_64 randomEngine(seed);
  std::uniform_real_distribution<double> uniformPdf(0., 1.);
  std::vector<flat_set<std::size_t>> firedLegs(leptonEfficiencies.size());
  unsigned long nPassed[2] = {0, 0};
  for (unsigned long toy = 0; toy < m_parent->m_numberOfToys; ++toy) {
    for (int step = 0; step < 2; ++step)  
    {
      auto legs = firedLegs.begin();
      for (auto& kv : leptonEfficiencies) {
        legs->clear();
        double x = uniformPdf(randomEngine);
        for (auto& p : kv.second) {
          if (x < (step ? p.second.mc() : p.second.data()))
            legs->emplace(p.first);
        }
        ++legs;
      }
      for (auto& trig : triggers) {
        if (!canTriggerBeFired(trig, firedLegs))
          continue;
        ++nPassed[step];
        break;
      }
    }
  }
  globalEfficiencies.data() =
      double(nPassed[0]) / double(m_parent->m_numberOfToys);
  globalEfficiencies.mc() =
      double(nPassed[1]) / double(m_parent->m_numberOfToys);
  return true;
}
 
Calculator::Helper::Helper(const std::vector<TrigDef>& defs)
    : m_formula(nullptr), m_defs(defs) {}
 
bool Calculator::Helper::duplicates() const {
  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;
}
 
namespace TrigGlobEffCorr  
{
template <typename T>
struct TrigGlobEffCorr::Calculator::Helper::BindPackedParam {
  using TrigType = T;
  using ArgType = std::add_const_t<T>;
  static constexpr bool multiple() { return false; }
  static constexpr bool optional() { return false; }
  static void add(T& arg, ImportData::TrigDef& def) { arg.setDefinition(def); }
  static constexpr bool valid(const T& arg) { return bool(arg); }
};
 
template <typename T>
struct TrigGlobEffCorr::Calculator::Helper::BindPackedParam<flat_set<T>> {
  using TrigType = T;
  using ArgType = const flat_set<T>&;
  static constexpr bool multiple() { return true; }
  static constexpr bool optional() { return false; }
  static void add(flat_set<T>& arg, ImportData::TrigDef& def) {
    arg.emplace().first->setDefinition(def);
  }
  static constexpr bool valid(const flat_set<T>& arg) { return arg.size(); }
};
 
template <typename T>
struct TrigGlobEffCorr::Calculator::Helper::BindPackedParam<
    Calculator::Helper::Optional<T>> {
  using TrigType = typename BindPackedParam<T>::TrigType;
  using ArgType = typename BindPackedParam<T>::ArgType;
  static constexpr bool multiple() { return BindPackedParam<T>::multiple(); }
  static constexpr bool optional() { return true; }
  static void add(std::remove_cv_t<std::remove_reference_t<ArgType>>& arg,
                  ImportData::TrigDef def) {
    BindPackedParam<T>::add(arg, def);
  }
  static constexpr bool valid(ArgType& arg) {
    return BindPackedParam<T>::valid(arg);
  }
};
}  // namespace TrigGlobEffCorr
 
template <typename Param>
auto Calculator::Helper::extract() {
  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;
}
 
template <typename... Trigs>
bool Calculator::Helper::bindFunction() {
  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;
}
 
template <TriggerType object_flag>
bool Calculator::Helper::findAndBindFunction()  
{
  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;
}
 
template <TriggerType object_flag1, TriggerType object_flag2>
bool Calculator::Helper::findAndBindFunction()  
{
  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;
}
 
bool Calculator::Helper::findAndBindFunction()  
{
  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;
}