ImportData.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
// contact: jmaurer@cern.ch
 
#include "TrigGlobalEfficiencyCorrection/ImportData.h"
 
#include <algorithm>
#include <fstream>
#include <functional>
#include <limits>
 
#include "PathResolver/PathResolver.h"
 
using ImportData = TrigGlobEffCorr::ImportData;
 
ImportData::ImportData()
    :  
      asg::AsgMessaging("TrigGlobalEfficiencyCorrectionTool"),
      m_parent(nullptr),
      m_dictionary(*new std::map<std::size_t, std::string>),
      m_hasher(*new std::hash<std::string>) {}
 
ImportData::ImportData(TrigGlobalEfficiencyCorrectionTool& parent)
    : asg::AsgMessaging(&parent),
      m_parent(&parent),
      m_dictionary(parent.m_dictionary),
      m_hasher(parent.m_hasher) {
  msg().setLevel(parent.msg().level());
}
 
ImportData::~ImportData() {
  if (!m_parent) {
    delete &m_dictionary;
    delete &m_hasher;
  }
}
 
bool ImportData::importAll(
    const std::map<std::string, std::string>& overridenThresholds) {
  return importPeriods() && importThresholds(overridenThresholds) &&
         importTriggers() && importHierarchies();
}
 
bool ImportData::readDataFile(const char* filename,
                              std::vector<std::string>& contents) {
  contents.clear();
  bool success = true;
  auto name = PathResolverFindCalibFile(filename);
  if (name.length()) {
    std::ifstream f(name.c_str(), std::ios_base::in);
    if (f.is_open()) {
      std::string line;
      while (f.good()) {
        if (std::getline(f, line)) {
          const std::string::size_type i = line.find('#');
          if (i != std::string::npos)
            line.resize(i);
          if (line.length() >= 3)
            contents.emplace_back(std::move(line));
        }
      }
      if (!f.eof()) {
        ATH_MSG_ERROR("Issue encountered while reading configuration file "
                      << filename);
        success = false;
      }
      f.close();
      return true;
    } else {
      ATH_MSG_ERROR("Unable to open configuration file " << filename);
      success = false;
    }
  } else {
    ATH_MSG_ERROR("Unable to find configuration file " << filename);
    success = false;
  }
  return success;
}
 
void ImportData::setNonMixed3LType(TrigDef& def, TriggerType flavourFlag) {
  if (def.leg[0] == def.leg[1] && def.leg[1] == def.leg[2])
    def.type = static_cast<TriggerType>(TT_TRILEPTON_SYM | flavourFlag);
  else if (def.leg[0] != def.leg[1] && def.leg[1] != def.leg[2] &&
           def.leg[0] != def.leg[2])
    def.type = static_cast<TriggerType>(TT_TRILEPTON_ASYM | flavourFlag);
  else  
  {
    if (def.leg[1] != def.leg[0] && def.leg[1] != def.leg[2])
      std::swap(def.leg[0], def.leg[1]);
    else if (def.leg[2] != def.leg[0] && def.leg[2] != def.leg[1])
      std::swap(def.leg[0], def.leg[2]);
    def.type = static_cast<TriggerType>(TT_TRILEPTON_HALFSYM | flavourFlag);
  }
}
 
bool ImportData::importTriggers() {
  if (!m_triggerThresholds.size() && !importThresholds())
    return false;
  m_triggerDefs.clear();
  std::vector<std::string> config;
  if (!readDataFile("TrigGlobalEfficiencyCorrection/Triggers.cfg", config))
    return false;
  std::stringstream ss;
  std::string triggerName, token;
  bool success = true;
  for (auto& line : config) {
    ATH_MSG_DEBUG(line);
    ss.clear();
    ss.str(line);
    ss >> triggerName;
    std::size_t h = m_hasher(triggerName);
    auto& def = m_triggerDefs[h];
    def.name = h;
 
    ss.clear();
    ss.str(line);
    ss >> triggerName;
    m_dictionary[h] = triggerName;
    ATH_MSG_DEBUG(std::to_string(h) << " " << triggerName);
 
    bool hasTauLeg{};
    for (std::size_t& leg : def.leg) {
      if (!(ss >> token))
        break;
      auto flavour = associatedLeptonFlavour(token, success);
      if (flavour == xAOD::Type::Tau) {
        // we don't support taus for now
        leg = 0;
        hasTauLeg = true;
      } else {
        h = m_hasher(token);
        m_dictionary.emplace(h, token);
        leg = h;
        if (m_triggerThresholds.find(h) == m_triggerThresholds.end()) {
          ATH_MSG_ERROR("Unknown trigger leg '" << token
                                                << "' found in Triggers.cfg");
          success = false;
        }
      }
    }
    if (!def.leg[0]) {
      def.leg[0] = h;  
      if (m_triggerThresholds.find(h) == m_triggerThresholds.end()) {
        ATH_MSG_ERROR(
            "Unknown trigger leg '"
            << triggerName
            << "' (inferred from trigger name) found in Triggers.cfg");
        success = false;
      }
    }
    if (!success)
      continue;
 
    def.type = TT_UNKNOWN;
    // triggers with tau legs should stay unknown
    if (hasTauLeg) {
      continue;
    }
 
    auto flavour0 = associatedLeptonFlavour(def.leg[0], success);
    int ne = (flavour0 == xAOD::Type::Electron) * 1;
    int nm = (flavour0 == xAOD::Type::Muon) * 1;
    if (def.leg[1]) {
      auto flavour1 = associatedLeptonFlavour(def.leg[1], success);
      if (flavour1 == xAOD::Type::Electron) {
        if (!ne)
          std::swap(def.leg[0], def.leg[1]);
        ++ne;
      } else if (flavour1 == xAOD::Type::Muon) {
        if (!(ne + nm))
          std::swap(def.leg[0], def.leg[1]);
        ++nm;
      } else if (flavour1 != xAOD::Type::Photon)
        success = false;
      if (def.leg[2]) {
        auto flavour2 = associatedLeptonFlavour(def.leg[2], success);
        if (flavour2 == xAOD::Type::Electron) {
          if (!ne)
            std::swap(def.leg[0], def.leg[2]);
          else if (ne == 1)
            std::swap(def.leg[1], def.leg[2]);
          ++ne;
        } else if (flavour2 == xAOD::Type::Muon) {
          if (!(ne + nm))
            std::swap(def.leg[0], def.leg[2]);
          else if ((ne + nm) == 1)
            std::swap(def.leg[1], def.leg[2]);
          ++nm;
        } else if (flavour2 != xAOD::Type::Photon)
          success = false;
        if (def.leg[3]) {
          if (std::count(def.leg.cbegin(), def.leg.cend(), def.leg[0]) == 4) {
            def.type = nm ? TT_4MU_SYM : TT_4E_SYM;
          } else
            success = false;
        } else if (ne + nm == 0 || ne == 3 ||
                   nm == 3)  
        {
          setNonMixed3LType(def, (ne   ? TT_ELECTRON_FLAG
                                  : nm ? TT_MUON_FLAG
                                       : TT_PHOTON_FLAG));
        } else  
        {
          bool sym = (def.leg[0] == def.leg[1] || def.leg[1] == def.leg[2]);
          if (ne == 2)
            def.type = nm ? (sym ? TT_2E_MU_SYM : TT_2E_MU_ASYM)
                          : (sym ? TT_2E_G_SYM : TT_2E_G_ASYM);
          else if (nm == 2)
            def.type = ne ? (sym ? TT_E_2MU_SYM : TT_E_2MU_ASYM)
                          : (sym ? TT_2MU_G_SYM : TT_2MU_G_ASYM);
          else if (ne + nm == 1)
            def.type = ne ? (sym ? TT_E_2G_SYM : TT_E_2G_ASYM)
                          : (sym ? TT_MU_2G_SYM : TT_MU_2G_ASYM);
          else
            success = false;
        }
      } else  
      {
        if (ne == 2)
          def.type = (def.leg[0] == def.leg[1]) ? TT_2E_SYM : TT_2E_ASYM;
        else if (nm == 2)
          def.type = (def.leg[0] == def.leg[1]) ? TT_2MU_SYM : TT_2MU_ASYM;
        else if (ne + nm == 0)
          def.type = (def.leg[0] == def.leg[1]) ? TT_2G_SYM : TT_2G_ASYM;
        else if (ne == 1 && nm == 1)
          def.type = TT_E_MU;
        else if (ne == 1)
          def.type = TT_E_G;
        else if (nm == 1)
          def.type = TT_MU_G;
      }
    } else  
    {
      def.type = ne ? TT_SINGLE_E : nm ? TT_SINGLE_MU : TT_SINGLE_G;
    }
    if (!success || def.type == TT_UNKNOWN) {
      success = false;
      ATH_MSG_ERROR("Configuration issue for trigger " << triggerName);
    }
  }
  return success;
}
 
bool ImportData::importThresholds(
    const std::map<std::string, std::string>& overridenThresholds) {
  m_triggerThresholds.clear();
  std::vector<std::string> config;
  if (!readDataFile("TrigGlobalEfficiencyCorrection/Thresholds.cfg", config))
    return false;
  std::stringstream ss;
  std::string leg, unit;
  float pt;
  bool success = true;
  for (auto& line : config) {
    ss.clear();
    ss.str(line);
    if (ss >> leg >> pt >> unit) {
      std::size_t h = m_hasher(leg);
      m_dictionary.emplace(h, leg);
      if (unit == "GeV")
        pt *= 1e3f;
      else if (unit != "MeV") {
        ATH_MSG_ERROR("Unable to import pT threshold for leg \""
                      << leg << "\" (missing unit)");
        success = false;
      }
      m_triggerThresholds[h] = pt;
    } else {
      ATH_MSG_ERROR("Unable to import pT threshold for leg \"" << leg << '"');
      success = false;
    }
  }
  if (!success) {
    m_triggerThresholds.clear();
    return false;
  }
 
  bool belowRecommended = false;
  for (auto& kv : overridenThresholds) {
    auto itr = m_triggerThresholds.find(m_hasher(kv.first));
    if (itr != m_triggerThresholds.end()) {
      float pt = 0.f;
      try {
        pt = std::stof(kv.second);
      } catch (...) {
        ATH_MSG_ERROR("Unable to convert threshold argument \""
                      << kv.second << "\" to floating-point value");
        success = false;
        continue;
      }
      if (pt < 1e3f) {
        ATH_MSG_WARNING("Suspiciously low threshold ("
                        << pt << " MeV) set for trigger leg " << kv.first
                        << ", please make sure you provided the threshold in "
                           "MeV and not in GeV!");
      }
      if (pt < itr->second)
        belowRecommended = true;
      itr->second = pt;
    } else {
      ATH_MSG_ERROR("Can't override threshold for unknown trigger leg "
                    << kv.first);
      success = false;
    }
  }
  if (belowRecommended) {
    ATH_MSG_WARNING(
        "Tool configured to use trigger thresholds below those recommended!");
  }
  return success;
}
 
bool ImportData::importPeriods() {
  m_dataPeriods.clear();
  std::vector<std::string> config;
  if (!readDataFile("TrigGlobalEfficiencyCorrection/DataPeriods.cfg", config))
    return false;
  std::stringstream ss;
  std::string key;
  std::pair<unsigned, unsigned> runs;
  for (auto& line : config) {
    ss.clear();
    ss.str(line);
    ss >> key >> runs.first >> runs.second;
    if (ss.fail()) {
      m_dataPeriods.clear();
      return false;
    }
    m_dataPeriods.emplace(key, runs);
  }
  return true;
}
 
bool ImportData::importHierarchies() {
  if (!m_triggerThresholds.size() && !importThresholds())
    return false;
  m_hierarchyMeta.clear();
  m_hierarchyData.clear();
  std::vector<std::string> config;
  if (!readDataFile("TrigGlobalEfficiencyCorrection/Hierarchies.cfg", config))
    return false;
  std::stringstream ss;
  std::string token, unit;
  std::map<std::size_t, std::vector<std::size_t> > aliases;
  for (auto& line : config) {
    bool success = true;
    ss.clear();
    ss.str(line);
    if (line[0] == '[') {
      auto& meta = *m_hierarchyMeta.emplace(
          m_hierarchyMeta.end(),
          Hierarchy{(short)m_hierarchyData.size(), 0, 0.f,
                    std::numeric_limits<float>::max()});
      if (line[1] == '-' && line[2] == ']')
        ss.ignore(3);
      else {
        char sep = '-';
        if (line[1] == '>')
          ss.ignore(2) >> meta.minPt >> unit;
        else if (line[1] == '<')
          ss.ignore(2) >> meta.maxPt >> unit;
        else
          ss.ignore(1) >> meta.minPt >> sep >> meta.maxPt >> unit;
        if (!ss || sep != '-' || (unit != "GeV]" && unit != "MeV]")) {
          ATH_MSG_ERROR("Unable to parse pT restrictions in Hierarchies.cfg");
          success = false;
        }
        if (unit == "GeV]") {
          meta.minPt *= 1e3f;
          if (meta.maxPt < std::numeric_limits<float>::max())
            meta.maxPt *= 1e3f;
        }
      }
      while (ss >> token) {
        std::size_t h = m_hasher(token);
        auto itr = aliases.find(h);
        if (itr == aliases.end()) {
          if (m_triggerThresholds.find(h) == m_triggerThresholds.end()) {
            ATH_MSG_ERROR("Unknown trigger leg '"
                          << token << "' found in Hierarchies.cfg");
            success = false;
          }
          m_dictionary.emplace(h, token);
          m_hierarchyData.push_back(h);
        } else
          m_hierarchyData.insert(m_hierarchyData.end(), itr->second.begin(),
                                 itr->second.end());
        if (ss >> token && token != ">")
          success = false;
      }
      meta.nLegs = m_hierarchyData.size() - meta.offset;
      success = success && meta.nLegs;
    } else {
      ss >> token;
      auto& legs = aliases[m_hasher(token)];
      if (ss >> token && token == ":=") {
        legs.clear();
        while (ss >> token) {
          std::size_t h = m_hasher(token);
          m_dictionary.emplace(h, token);
          legs.push_back(h);
          if (m_triggerThresholds.find(h) == m_triggerThresholds.end()) {
            ATH_MSG_ERROR("Unknown trigger leg '"
                          << token << "' found in Hierarchies.cfg");
            success = false;
          }
          if (ss >> token && token != ">")
            success = false;
        }
        success = success && legs.size();
      } else
        success = false;
    }
    if (!success) {
      ATH_MSG_ERROR("Failed parsing line from Hierarchies.cfg:\n" << line);
      m_hierarchyMeta.clear();
      m_hierarchyData.clear();
      return false;
    }
  }
  return true;
}
 
bool ImportData::importMapKeys(
    const std::string& version,
    std::map<std::size_t, std::map<std::size_t, int> >& keysPerLeg) {
  keysPerLeg.clear();
  std::vector<std::string> config;
  if (!readDataFile("TrigGlobalEfficiencyCorrection/MapKeys.cfg", config))
    return false;
  std::stringstream ss;
  std::string token;
  bool reading = false;
  for (auto& line : config) {
    std::size_t pos = line.find("[VERSION]");
    if (pos != std::string::npos) {
      reading = false;
      ss.clear();
      ss.str(TrigGlobEffCorr::removeWhitespaces(line.substr(pos + 9)));
      while (std::getline(ss, token, ',')) {
        if (token == version) {
          reading = true;
          break;
        }
      }
      continue;
    }
    if (!reading)
      continue;
    ss.clear();
    ss.str(line);
    int year;
    ss >> year >> token;
    year = 1 << (year - 2015);
    std::size_t leg = m_hasher(token);
    auto& keys = keysPerLeg[leg];
    while (ss >> token) {
      std::size_t h = m_hasher(token);
      auto insertion = keys.emplace(h, year);
      if (insertion.second)
        m_dictionary.emplace(h, token);
      else
        insertion.first->second |= year;
    }
  }
  if (!keysPerLeg.size()) {
    ATH_MSG_ERROR("Unable to import the available map keys for the version "
                  << version);
    return false;
  }
  return true;
}
 
bool ImportData::getPeriodBoundaries(
    const std::string& period, std::pair<unsigned, unsigned>& boundaries) {
  // First possibility: a defined period keyword
  auto itr = m_dataPeriods.find(period);
  if (itr != m_dataPeriods.end()) {
    boundaries = itr->second;
    return true;
  }
  // Otherwise it's a '-'-separated range
  auto sep = period.find_first_of('-');
  if (sep != std::string::npos) {
    std::string kwMin = period.substr(0, sep);
    std::string kwMax = period.substr(sep + 1);
    // Second possibility: a range of defined period keywords
    auto itrMin = m_dataPeriods.find(kwMin);
    auto itrMax = m_dataPeriods.find(kwMax);
    if (itrMin != m_dataPeriods.end() && itrMax != m_dataPeriods.end()) {
      boundaries = std::minmax({itrMin->second.first, itrMax->second.first,
                                itrMin->second.second, itrMax->second.second});
      return true;
    }
    // Third possibility: a range of run numbers
    try {
      boundaries = std::minmax(std::stoi(kwMin), std::stoi(kwMax));
      return true;
    } catch (...) {
    }
  }
  ATH_MSG_ERROR("Unable to understand the period/range " << period);
  return false;
}
 
xAOD::Type::ObjectType ImportData::associatedLeptonFlavour(
    const std::string& leg, bool& success) {
  // note: 'success' is not set to 'true', only downgraded to 'false' if needed
  if (leg.length() >= 2 && leg[0] == 'e' && leg[1] >= '1' && leg[1] <= '9')
    return xAOD::Type::Electron;
  else if (leg.length() >= 3 && leg[0] == 'm' && leg[1] == 'u' &&
           leg[2] >= '1' && leg[2] <= '9')
    return xAOD::Type::Muon;
  else if (leg.length() >= 3 && leg[0] == 'g' && leg[1] >= '1' && leg[1] <= '9')
    return xAOD::Type::Photon;
  else if (leg.length() >= 4 && leg[0] == 't' && leg[1] == 'a' &&
           leg[2] == 'u' && leg[3] >= '1' && leg[3] <= '9')
    return xAOD::Type::Tau;
  success = false;
  return xAOD::Type::Other;
}
 
xAOD::Type::ObjectType ImportData::associatedLeptonFlavour(std::size_t leg,
                                                           bool& success) {
  // note: 'success' is not set to 'true', only downgraded to 'false' if needed
  auto itr = m_dictionary.find(leg);
  if (itr != m_dictionary.end()) {
    return associatedLeptonFlavour(itr->second, success);
  }
  success = false;
  return xAOD::Type::Other;
}
 
std::vector<ImportData::TrigDef> ImportData::parseTriggerString(
    const std::string& triggerString, bool& success) {
  std::string s = TrigGlobEffCorr::removeWhitespaces(triggerString);
  if (s.find("|||") != std::string::npos) {
    ATH_MSG_ERROR("Invalid format for the trigger combination '"
                  << triggerString << "'");
    success = false;
    return {};
  }
  while (true) {
    auto i = s.find("||");
    if (i == std::string::npos)
      break;
    s.replace(i, 1, "");
  }
  if (s == "" || s == "|") {
    ATH_MSG_ERROR("Invalid format for the trigger combination '"
                  << triggerString << "'");
    success = false;
    return {};
  }
  std::vector<TrigDef> triggers;
  std::set<std::size_t> hashes;
  std::stringstream ss(s);
  while (std::getline(ss, s, '|')) {
    std::size_t trig = m_hasher(s);
    ATH_MSG_DEBUG(std::to_string(trig) << " --> " << s);
    auto itr = m_triggerDefs.find(trig);
    if (itr == m_triggerDefs.end()) {
      ATH_MSG_ERROR("Unknown trigger '"
                    << s << "' found while parsing trigger combination");
      success = false;
      return {};
    }
    if (!hashes.insert(trig).second) {
      ATH_MSG_ERROR("The trigger '"
                    << s << "' is present more than once in the combination");
      success = false;
      return {};
    }
    triggers.push_back(itr->second);
  }
  success = success && triggers.size();
  return triggers;
}
 
bool ImportData::suggestEgammaMapKeys(
    const std::map<std::string, std::string>& triggerCombination,
    const std::string& version, std::map<std::string, std::string>& legsPerKey,
    xAOD::Type::ObjectType type) {
  legsPerKey.clear();
  if (!importAll())
    return false;
 
  bool success = true;
  std::map<std::size_t, int> legs;
 
  for (auto& kv : triggerCombination) {
    auto itrPeriod = m_dataPeriods.find(kv.first);
    if (itrPeriod == m_dataPeriods.end()) {
      ATH_MSG_ERROR("Unknown period " << kv.first);
      success = false;
      continue;
    }
    int years = 0;
    for (int k = 0; k < 32; ++k) {
      auto itr = m_dataPeriods.find(std::to_string(2015 + k));
      if (itr != m_dataPeriods.end() &&
          itrPeriod->second.first <= itr->second.second &&
          itrPeriod->second.second >= itr->second.first) {
        years |= (1 << k);
      }
    }
    auto triggers = parseTriggerString(kv.second, success);
    if (!success)
      continue;
    for (auto& trig : triggers) {
      for (std::size_t leg : trig.leg) {
        if (leg && associatedLeptonFlavour(leg, success) == type) {
          auto insertion = legs.emplace(leg, years);
          if (!insertion.second)
            insertion.first->second |= years;
        }
      }
    }
  }
  if (!success)
    return false;
 
  if (version != "") {
    std::map<std::size_t, std::map<std::size_t, int> > allKeys;
    if (!importMapKeys(version, allKeys))
      return false;
    std::map<std::size_t, std::vector<std::size_t> > allLegsPerKey;
    std::set<std::size_t> legsWithMultipleKeys;
    bool sameKeyForAllyears = true;
    while (legs.size()) {
      allLegsPerKey.clear();
      for (auto& kvLegs : legs)  // loop on remaining legs
      {
        std::size_t leg = kvLegs.first;
        int years = kvLegs.second;
        auto itrKeys = allKeys.find(leg);  // list of keys for that leg
        if (itrKeys != allKeys.end()) {
          for (auto& kvKeys : itrKeys->second)  // loop on those keys
          {
            auto y = (kvKeys.second & years);
            if ((y == years) ||
                (!sameKeyForAllyears &&
                 y != 0))  // key must support all years needed for that leg --
                           // until no longer possible
            {
              auto insertion = allLegsPerKey.emplace(
                  kvKeys.first, std::vector<std::size_t>{leg});
              if (!insertion.second)
                insertion.first->second.push_back(leg);
            }
          }
        } else {
          ATH_MSG_ERROR(
              "Sorry, no idea what the map key should be for the trigger leg '"
              << m_dictionary.at(leg) << "', manual configuration is needed");
          success = false;
        }
      }
      if (!success)
        break;
 
      if (!allLegsPerKey.size()) {
        if (sameKeyForAllyears) {
          sameKeyForAllyears = false;
          continue;
        }
        success = false;
        break;
      }
 
      using T = decltype(allLegsPerKey)::value_type;
      auto itrKey = std::max_element(
          allLegsPerKey.begin(), allLegsPerKey.end(),
          [](T& x, T& y) { return x.second.size() < y.second.size(); });
      std::string& strLegs = legsPerKey[m_dictionary.at(itrKey->first)];
      for (std::size_t leg : itrKey->second) {
        int& wantedYears = legs.at(leg);
        int supportedYears = (allKeys.at(leg).at(itrKey->first)) & wantedYears;
        if (supportedYears != wantedYears || legsWithMultipleKeys.count(leg)) {
          legsWithMultipleKeys.insert(leg);
          for (int i = 0; i < 32; ++i) {
            if (supportedYears & (1u << i)) {
              if (strLegs.length() && strLegs.back() != ',')
                strLegs += ',';
              strLegs +=
                  m_dictionary.at(leg) + "[" + std::to_string(2015 + i) + "]";
            }
          }
        } else {
          if (strLegs.length() && strLegs.back() != ',')
            strLegs += ',';
          strLegs += m_dictionary.at(leg);
        }
        if (supportedYears == wantedYears)
          legs.erase(leg);
        else
          wantedYears &= ~supportedYears;
      }
    }
  } else {
    for (auto& kv : legs) {
      legsPerKey.emplace(std::to_string(legsPerKey.size()),
                         m_dictionary.at(kv.first));
    }
  }
  for (auto& [key, legs] : legsPerKey) {
    if (key ==
        ITrigGlobalEfficiencyCorrectionTool::toolnameForDefaultScaleFactor()) {
      ATH_MSG_WARNING(
          "Some of the requested triggers will result in "
          "a default scale factor of 1 being returned");
    }
  }
  if (!success)
    legsPerKey.clear();
  return success;
}
 
bool ImportData::adaptTriggerListForTriggerMatching(
    std::vector<ImportData::TrigDef>& triggers) {
  std::set<std::size_t> extraItems;  
  std::vector<ImportData::TrigDef> updatedTriggers;
  for (auto& trig : triggers) {
    auto& name = m_dictionary.at(trig.name);
    std::size_t pos = 0, len = name.find("_OR_");
    if (len == std::string::npos) {
      updatedTriggers.emplace_back(trig);
      continue;
    }
    while (true) {
      std::string item = name.substr(pos, len);
      auto h = m_hasher(item);
      auto def = m_triggerDefs.find(h);
      if (def == m_triggerDefs.end()) {
        ATH_MSG_ERROR("while listing triggers for trigger matching; trigger \""
                      << item << "\" extracted from \"" << name
                      << "\" is not recognized");
        return false;
      }
      if (extraItems.emplace(h).second)
        updatedTriggers.emplace_back(def->second);
      if (len == std::string::npos)
        break;
      pos += len + 4;
      len = name.find("_OR_", pos);
      if (len != std::string::npos)
        len -= pos;
    }
  }
  triggers.swap(updatedTriggers);
  return true;
}