CheckConfig.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
*/
 
// contact: jmaurer@cern.ch
 
#include "TrigGlobalEfficiencyCorrection/CheckConfig.h"
 
#include <boost/container/flat_set.hpp>
 
#include "TrigGlobalEfficiencyCorrection/Calculator.h"
#include "TrigGlobalEfficiencyCorrection/ImportData.h"
template <typename Key>
using flat_set = boost::container::flat_set<Key>;
 
#include <cctype>
 
using CheckConfig = TrigGlobEffCorr::CheckConfig;
using ImportData = TrigGlobEffCorr::ImportData;
 
CheckConfig::CheckConfig(TrigGlobalEfficiencyCorrectionTool& parent)
    : asg::AsgMessaging(&parent), m_parent(parent) {
  msg().setLevel(parent.msg().level());
}
 
template <class CPTool>
ToolHandle<CPTool>* CheckConfig::findToolByName(
    ToolHandleArray<CPTool>& suppliedTools, const std::string& name) {
  for (auto& tool : suppliedTools) {
    if (tool.name() == name ||
        tool->name() == name)  // athena: not always the same
    {
      return &tool;
    }
  }
  return nullptr;
}
 
bool CheckConfig::basicConfigChecks() {
  bool success = true;
 
  if (m_parent.m_suppliedElectronEfficiencyTools.size() !=
      m_parent.m_suppliedElectronScaleFactorTools.size()) {
    ATH_MSG_ERROR(
        "The numbers of electron tools supplied via the "
        "'ElectronEfficiencyTools' and 'ElectronScaleFactorTools' properties "
        "should be identical");
    return false;
  }
 
  if (m_parent.m_suppliedPhotonEfficiencyTools.size() !=
      m_parent.m_suppliedPhotonScaleFactorTools.size()) {
    ATH_MSG_ERROR(
        "The numbers of photon tools supplied via the 'PhotonEfficiencyTools' "
        "and 'PhotonScaleFactorTools' properties should be identical");
    return false;
  }

  for (auto& kv : m_parent.m_legsPerTool) {
    auto& name = kv.first;
    if (name ==
        ITrigGlobalEfficiencyCorrectionTool::toolnameForDefaultScaleFactor())
      continue;
    if (findToolByName(m_parent.m_suppliedElectronEfficiencyTools, name) ||
        findToolByName(m_parent.m_suppliedElectronScaleFactorTools, name) ||
        findToolByName(m_parent.m_suppliedPhotonEfficiencyTools, name) ||
        findToolByName(m_parent.m_suppliedPhotonScaleFactorTools, name))
      continue;
    success = false;
    if (findToolByName(m_parent.m_suppliedMuonTools, name)) {
      ATH_MSG_ERROR("Muon tool "
                    << name
                    << " mentioned in property 'ListOfLegsPerTool', which is "
                       "only aimed at electron and photon tools");
    } else {
      std::string known_tools = "; the known tools are";
      for (auto& tool : m_parent.m_suppliedElectronEfficiencyTools)
        known_tools += " " + tool.name();
      for (auto& tool : m_parent.m_suppliedElectronScaleFactorTools)
        known_tools += " " + tool.name();
      for (auto& tool : m_parent.m_suppliedPhotonEfficiencyTools)
        known_tools += " " + tool.name();
      for (auto& tool : m_parent.m_suppliedPhotonScaleFactorTools)
        known_tools += " " + tool.name();
      ATH_MSG_ERROR("Unknown tool "
                    << name << " mentioned in property 'ListOfLegsPerTool'"
                    << known_tools);
    }
  }
  if (!success)
    return false;

  auto toolsHaveLegInfo = [this](auto& effTools, auto& sfTools,
                                 const char* type) {
    if (effTools.size() < 2)
      return true;
    bool success = true;
    for (int i = 0; i < 2; ++i) {
      for (auto& tool : (i ? effTools : sfTools)) {
        const std::string& name = tool.name();
        if (m_parent.m_legsPerTool.find(name) == m_parent.m_legsPerTool.end()) {
          ATH_MSG_ERROR(type
                        << " tool " << name
                        << " associated trigger legs are not indicated in "
                           "'ListOfLegsPerTool', "
                           "doing so is mandatory when several tools are used");
          success = false;
        }
      }
    }
    return success;
  };
  success &=
      toolsHaveLegInfo(m_parent.m_suppliedElectronEfficiencyTools,
                       m_parent.m_suppliedElectronScaleFactorTools, "Electron");
  success &=
      toolsHaveLegInfo(m_parent.m_suppliedPhotonEfficiencyTools,
                       m_parent.m_suppliedPhotonScaleFactorTools, "Photon");
  if (!success)
    return false;

 
  if (m_parent.m_leptonTagDecorations == "") {
    if (m_parent.m_muonLegsPerTag.size() ||
        m_parent.m_electronLegsPerTag.size() || m_parent.m_legsPerTag.size() ||
        m_parent.m_tagsPerTool.size()) {
      ATH_MSG_ERROR(
          "the property 'LeptonTagDecorations' must be filled when any of "
          "'ListOfTagsPerTool'"
          " / 'ListOfLegsPerTag' / 'MuonLegsPerTag' / 'ElectronLegsPerTag' "
          "is.");
      return false;
    }
    return true;
  }

  unsigned nElectronToolsWithTags = 0, nMuonToolsWithTags = 0,
           nPhotonToolsWithTags = 0;
  for (auto& kv : m_parent.m_tagsPerTool) {
    auto& name = kv.first;
    if (findToolByName(m_parent.m_suppliedElectronEfficiencyTools, name) ||
        findToolByName(m_parent.m_suppliedElectronScaleFactorTools, name))
      ++nElectronToolsWithTags;
    else if (findToolByName(m_parent.m_suppliedMuonTools, name))
      ++nMuonToolsWithTags;
    else if (findToolByName(m_parent.m_suppliedPhotonEfficiencyTools, name) ||
             findToolByName(m_parent.m_suppliedPhotonScaleFactorTools, name))
      ++nPhotonToolsWithTags;
    else {
      success = false;
      std::string all_tools = "; the known tools are";
      for (auto& tool : m_parent.m_suppliedElectronEfficiencyTools)
        all_tools += " " + tool.name();
      for (auto& tool : m_parent.m_suppliedElectronScaleFactorTools)
        all_tools += " " + tool.name();
      for (auto& tool : m_parent.m_suppliedPhotonEfficiencyTools)
        all_tools += " " + tool.name();
      for (auto& tool : m_parent.m_suppliedPhotonScaleFactorTools)
        all_tools += " " + tool.name();
      ATH_MSG_ERROR("Unknown tool "
                    << name << " mentioned in property 'ListOfTagsPerTool'");
    }
  }
  if (nMuonToolsWithTags &&
      (nMuonToolsWithTags != m_parent.m_suppliedMuonTools.size())) {
    ATH_MSG_ERROR(
        "Not all muon tools have been associated with tags in the "
        "'ListOfTagsPerTool' property");
    success = false;
  }
  unsigned nSupplied = m_parent.m_suppliedElectronEfficiencyTools.size() +
                       m_parent.m_suppliedElectronScaleFactorTools.size();
  if (nElectronToolsWithTags && (nElectronToolsWithTags != nSupplied)) {
    ATH_MSG_ERROR(
        "Not all electron tools have been associated with tags in the "
        "'ListOfTagsPerTool' property");
    success = false;
  }
  if (!success)
    return false;
  nSupplied = m_parent.m_suppliedPhotonEfficiencyTools.size() +
              m_parent.m_suppliedPhotonScaleFactorTools.size();
  if (nPhotonToolsWithTags && (nPhotonToolsWithTags != nSupplied)) {
    ATH_MSG_ERROR(
        "Not all photon tools have been associated with tags in the "
        "'ListOfTagsPerTool' property");
    success = false;
  }
  if (!success)
    return false;
 
  /*
   *  More checks that are done in other places (or still need to be
   * implemented!):
   *
   * - [advancedConfigChecks()] for each entry in ListOfLegsPerTag there must be
   * a suitable tool for that tag and leg(s)
   * - [enumerateTools()] no two electron/photon tools share the same {leg,tag}
   * combination
   * - [enumerateTools()] no two muon tools share the same tag
   * - [advancedConfigChecks()] electron efficiency and scale factors have
   * identical configurations: for each eff. tool leg/tag we must find a SF
   * tool, and the other leg/tag pairs associated to those tools must be
   * identical.
   * - [UNCHECKED] if tags are used with electron (resp. muon, photon) tools,
   * then all electron (muon, photon) tools must have an entry in
   * ListOfTagsPerTool. Done partially in this function, but the case where no
   * tools are tagged (yet tags are used, according to ListOfLegsPerTag or
   * LeptonTagDecorations) escapes detection.
   * - [loadTagsConfiguration()] each entry of ListOfLegsPerTag can be matched
   * to a suitable tool
   * - [UNCHECKED] suffixed tag read from a lepton must correspond to a know tag
   * - [enumerateTools()] list of legs associated to each tool contains only
   * known legs
   * - [UNCHECKED TrigGlobEffCorrImportData import* functions] various
   * consistency checks of the configuration files
   * - [advancedConfigChecks()] user-specified periods are orthogonal
   * - [ImportData::parseTriggerString()] no duplicated triggers in the
   * combination
   * - [UNCHECKED] for each configured electron/photon tool there is at least
   * one associated tag^leg pair in 'ListOfLegsPerTag' (unless no
   * electron/photon tags used)
   * - [UNCHECKED] for each configured muon tool there is at least one
   * associated tag in 'MuonLegsPerTag' (unless empty)
   * - [enumerateTools()] electron tools can't be associated to photon legs; and
   * reciprocally
   */
 
  return success;
}
 
bool CheckConfig::advancedConfigChecks() {
  bool success = true;
 
  using ToolKey = TrigGlobalEfficiencyCorrectionTool::ToolKey;

  auto checkConsistency = [this](auto& effToolIndex, auto& sfToolIndex,
                                 const char* type) {
    bool mismatch = (effToolIndex.size() != sfToolIndex.size());
    if (!mismatch) {
      for (auto& kv : sfToolIndex) {
        auto itr = effToolIndex.find(kv.first);
        if (itr != effToolIndex.end()) {
          std::size_t index1 = kv.second, index2 = itr->second;
          flat_set<ToolKey> pairs1, pairs2;
          for (auto& kv : sfToolIndex)
            if (kv.second == index1)
              pairs1.insert(kv.first);
          for (auto& kv : effToolIndex)
            if (kv.second == index2)
              pairs2.insert(kv.first);
          if (pairs1 != pairs2)
            mismatch = true;
        } else
          mismatch = true;
      }
    }
    if (mismatch) {
      ATH_MSG_ERROR(
          "There must be a one-to-one correspondence between the "
          << type
          << " efficiency and scale factor tools "
             "(including their associated trigger legs and selection tags)");
      return false;
    }
    return true;
  };
  if (!checkConsistency(m_parent.m_electronEffToolIndex,
                        m_parent.m_electronSfToolIndex, "electron"))
    return false;
  if (!checkConsistency(m_parent.m_photonEffToolIndex,
                        m_parent.m_photonSfToolIndex, "photon"))
    return false;

  for (auto& kv : m_parent.m_legsPerTag) {
    std::size_t tag = (kv.first != "*") ? m_parent.m_hasher(kv.first) : 0;
    for (std::size_t leg :
         m_parent.listNonOrderedCSValues(kv.second, success)) {
      auto type = ImportData::associatedLeptonFlavour(
          m_parent.m_dictionary[leg], success);
      if (type == xAOD::Type::Electron) {
        if (m_parent.m_electronEffToolIndex.find(ToolKey(leg, tag)) ==
            m_parent.m_electronEffToolIndex.end()) {
          ATH_MSG_ERROR(
              "No electron tool provided for the combination of trigger leg '"
              << m_parent.m_dictionary[leg] << "' and selection tag '"
              << kv.first << "' mentioned in the property 'ListOfLegsPerTag'");
          success = false;
        }
      } else if (type == xAOD::Type::Muon) {
        if (m_parent.m_muonToolIndex.find(ToolKey(0, tag)) ==
            m_parent.m_muonToolIndex.end()) {
          ATH_MSG_ERROR(
              "No muon tool provided for the combination of trigger leg '"
              << m_parent.m_dictionary[leg] << "' and selection tag '"
              << kv.first << "' mentioned in the property 'ListOfLegsPerTag'");
          success = false;
        }
      } else if (type == xAOD::Type::Photon) {
        if (m_parent.m_photonEffToolIndex.find(ToolKey(leg, tag)) ==
            m_parent.m_photonEffToolIndex.end()) {
          ATH_MSG_ERROR(
              "No photon tool provided for the combination of trigger leg '"
              << m_parent.m_dictionary[leg] << "' and selection tag '"
              << kv.first << "' mentioned in the property 'ListOfLegsPerTag'");
          success = false;
        }
      } else {
        ATH_MSG_ERROR(
            "Unable to determine which lepton flavour is associated to the "
            "trigger leg '"
            << m_parent.m_dictionary[leg]
            << "' in the property 'ListOfLegsPerTag'");
        success = false;
      }
    }
  }
  if (!success)
    return false;

  auto periods = m_parent.m_calculator->m_periods;
  const auto periods_end = periods.end();
  for (auto itr1 = periods.begin(); itr1 != periods_end; ++itr1) {
    auto& x = itr1->m_boundaries;
    if (x.second < x.first) {
      ATH_MSG_ERROR(
          "One of the periods specified in TriggerCombination has runMin ("
          << x.first << ") > runMax (" << x.second << ")");
      success = false;
    }
    for (auto itr2 = itr1 + 1; itr2 != periods_end; ++itr2) {
      auto& y = itr2->m_boundaries;
      if ((x.first >= y.first && x.first <= y.second) ||
          (x.second >= y.first && x.second <= y.second)) {
        ATH_MSG_ERROR("The periods specified in TriggerCombination overlap");
        success = false;
      }
    }
  }
  if (!success)
    return false;
 
  return success;
}