TrigGlobEffCorr::ImportData Class Reference

#include <ImportData.h>

Inheritance diagram for TrigGlobEffCorr::ImportData:

Collaboration diagram for TrigGlobEffCorr::ImportData:

Classes
struct	TrigDef

Public Member Functions
	ImportData ()
	the following two variables are owned by this tool and released in the destructor
	ImportData (TrigGlobalEfficiencyCorrectionTool &parent)
	~ImportData ()
bool	importHierarchies ()
bool	importTriggers ()
bool	importThresholds (const std::map< std::string, std::string > &overridenThresholds={})
bool	importPeriods ()
bool	importMapKeys (const std::string &tag, std::map< std::size_t, std::map< std::size_t, int > > &keysPerLeg)
bool	importAll (const std::map< std::string, std::string > &overridenThresholds={})
bool	getPeriodBoundaries (const std::string &period, std::pair< unsigned, unsigned > &boundaries)
bool	suggestEgammaMapKeys (const std::map< std::string, std::string > &triggerCombination, const std::string &version, std::map< std::string, std::string > &legsPerKey, xAOD::Type::ObjectType type)
const std::map< std::size_t, TrigDef > &	getTriggerDefs () const
const std::map< std::size_t, float > &	getTriggerThresholds () const
const std::map< std::string, std::pair< unsigned, unsigned > > &	getDataPeriods () const
const std::vector< Hierarchy > &	getHierarchyMeta () const
const std::vector< std::size_t > &	getHierarchyData () const
const std::map< std::size_t, std::string > &	getDictionary () const
xAOD::Type::ObjectType	associatedLeptonFlavour (std::size_t leg, bool &success)
std::vector< TrigDef >	parseTriggerString (const std::string &triggerString, bool &success)
TrigGlobalEfficiencyCorrectionTool *	getParent ()
bool	adaptTriggerListForTriggerMatching (std::vector< ImportData::TrigDef > &triggers)
void	setLevel (MSG::Level lvl)
	Change the current logging level.
Functions providing the same interface as AthMessaging
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

Static Public Member Functions
static xAOD::Type::ObjectType	associatedLeptonFlavour (const std::string &leg, bool &success)

Protected Member Functions
bool	readDataFile (const char *filename, std::vector< std::string > &contents)
void	setNonMixed3LType (TrigDef &def, TriggerType flavourFlag)

Protected Attributes
TrigGlobalEfficiencyCorrectionTool *	m_parent
std::map< std::size_t, std::string > &	m_dictionary
std::hash< std::string > &	m_hasher
std::map< std::size_t, TrigDef >	m_triggerDefs
std::map< std::size_t, float >	m_triggerThresholds
std::map< std::string, std::pair< unsigned, unsigned > >	m_dataPeriods
std::vector< Hierarchy >	m_hierarchyMeta
std::vector< std::size_t >	m_hierarchyData

Private Types
using	Hierarchy = TrigGlobalEfficiencyCorrectionTool::Hierarchy

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Definition at line 86 of file ImportData.h.

Member Typedef Documentation

Hierarchy

using TrigGlobEffCorr::ImportData::Hierarchy = TrigGlobalEfficiencyCorrectionTool::Hierarchy

private

Definition at line 87 of file ImportData.h.

Constructor & Destructor Documentation

ImportData() [1/2]

ImportData::ImportData

(

)

the following two variables are owned by this tool and released in the destructor

Definition at line 18 of file ImportData.cxx.

    :  
      asg::AsgMessaging("TrigGlobalEfficiencyCorrectionTool"),
      m_parent(nullptr),
      m_dictionary(*new std::map<std::size_t, std::string>),
      m_hasher(*new std::hash<std::string>) {}

ImportData() [2/2]

ImportData::ImportData

(

TrigGlobalEfficiencyCorrectionTool &

parent

)

Definition at line 26 of file ImportData.cxx.

    : asg::AsgMessaging(&parent),
      m_parent(&parent),
      m_dictionary(parent.m_dictionary),
      m_hasher(parent.m_hasher) {
  msg().setLevel(parent.msg().level());
}

~ImportData()

ImportData::~ImportData

(

)

Definition at line 34 of file ImportData.cxx.

                        {
  if (!m_parent) {
    delete &m_dictionary;
    delete &m_hasher;
  }
}

Member Function Documentation

adaptTriggerListForTriggerMatching()

bool ImportData::adaptTriggerListForTriggerMatching

(

std::vector< ImportData::TrigDef > &

triggers

)

This essentially splits OR single lepton triggers into independent items

to prevent duplicates

Definition at line 729 of file ImportData.cxx.

                                            {
  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;
}

associatedLeptonFlavour() [1/2]

xAOD::Type::ObjectType ImportData::associatedLeptonFlavour ( const std::string & leg, bool & success )

static

Definition at line 514 of file ImportData.cxx.

                                         {
  // 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;
}

associatedLeptonFlavour() [2/2]

xAOD::Type::ObjectType ImportData::associatedLeptonFlavour	(	std::size_t	leg,
		bool &	success )

Definition at line 531 of file ImportData.cxx.

                                                                          {
  // 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;
}

getDataPeriods()

const std::map< std::string, std::pair< unsigned, unsigned > > & TrigGlobEffCorr::ImportData::getDataPeriods ( ) const

inline

Definition at line 132 of file ImportData.h.

            {
    return m_dataPeriods;
  }

getDictionary()

const std::map< std::size_t, std::string > & TrigGlobEffCorr::ImportData::getDictionary ( ) const

inline

Definition at line 142 of file ImportData.h.

                                                            {
    return m_dictionary;
  }

getHierarchyData()

const std::vector< std::size_t > & TrigGlobEffCorr::ImportData::getHierarchyData ( ) const

inline

Definition at line 139 of file ImportData.h.

                                                       {
    return m_hierarchyData;
  }

getHierarchyMeta()

const std::vector< Hierarchy > & TrigGlobEffCorr::ImportData::getHierarchyMeta ( ) const

inline

Definition at line 136 of file ImportData.h.

                                                       {
    return m_hierarchyMeta;
  }

getParent()

TrigGlobalEfficiencyCorrectionTool * TrigGlobEffCorr::ImportData::getParent ( )

inline

Definition at line 151 of file ImportData.h.

{ return m_parent; }

getPeriodBoundaries()

bool ImportData::getPeriodBoundaries	(	const std::string &	period,
		std::pair< unsigned, unsigned > &	boundaries )

Definition at line 482 of file ImportData.cxx.

                                                                      {
  // 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;
}

getTriggerDefs()

const std::map< std::size_t, TrigDef > & TrigGlobEffCorr::ImportData::getTriggerDefs ( ) const

inline

Definition at line 126 of file ImportData.h.

                                                           {
    return m_triggerDefs;
  }

getTriggerThresholds()

const std::map< std::size_t, float > & TrigGlobEffCorr::ImportData::getTriggerThresholds ( ) const

inline

Definition at line 129 of file ImportData.h.

                                                               {
    return m_triggerThresholds;
  }

importAll()

bool ImportData::importAll

(

const std::map< std::string, std::string > &

overridenThresholds = {}

)

Definition at line 41 of file ImportData.cxx.

                                                             {
  return importPeriods() && importThresholds(overridenThresholds) &&
         importTriggers() && importHierarchies();
}

importHierarchies()

bool ImportData::importHierarchies

(

)

Definition at line 342 of file ImportData.cxx.

                                   {
  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;
}

importMapKeys()

bool ImportData::importMapKeys	(	const std::string &	tag,
		std::map< std::size_t, std::map< std::size_t, int > > &	keysPerLeg )

Definition at line 432 of file ImportData.cxx.

                                                            {
  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;
}

importPeriods()

bool ImportData::importPeriods

(

)

Definition at line 321 of file ImportData.cxx.

                               {
  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;
}

importThresholds()

bool ImportData::importThresholds

(

const std::map< std::string, std::string > &

overridenThresholds = {}

)

Override thresholds if requested

Definition at line 251 of file ImportData.cxx.

                                                             {
  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;
}

importTriggers()

bool ImportData::importTriggers

(

)

default: assume the leg's name is the same as the full trigger name

Classify trigger and re-arrange legs (if needed) so that all electron legs come before muon legs, and muon legs before photon legs

symmetric tetralepton triggers

single-flavour trilepton triggers

mixed-flavour trilepton triggers

dilepton triggers

single lepton triggers

Definition at line 99 of file ImportData.cxx.

                                {
  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;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns

A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns

A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns

boolean Indicting if messages at given level will be printed

true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

parseTriggerString()

std::vector< ImportData::TrigDef > ImportData::parseTriggerString	(	const std::string &	triggerString,
		bool &	success )

Replace all || by |

Definition at line 542 of file ImportData.cxx.

                                                   {
  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;
}

readDataFile()

bool ImportData::readDataFile ( const char * filename, std::vector< std::string > & contents )

protected

Definition at line 47 of file ImportData.cxx.

                                                              {
  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;
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setNonMixed3LType()

void ImportData::setNonMixed3LType ( TrigDef & def, TriggerType flavourFlag )

protected

swap legs so that the last two are identical, for later convenience

Definition at line 83 of file ImportData.cxx.

                                                                        {
  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);
  }
}

suggestEgammaMapKeys()

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 )

If no version is specified, the list of trigger legs is returned

Definition at line 589 of file ImportData.cxx.

                             {
  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;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_dataPeriods

std::map<std::string, std::pair<unsigned, unsigned> > TrigGlobEffCorr::ImportData::m_dataPeriods

protected

Definition at line 165 of file ImportData.h.

m_dictionary

std::map<std::size_t, std::string>& TrigGlobEffCorr::ImportData::m_dictionary

protected

Definition at line 160 of file ImportData.h.

m_hasher

std::hash<std::string>& TrigGlobEffCorr::ImportData::m_hasher

protected

Definition at line 161 of file ImportData.h.

m_hierarchyData

std::vector<std::size_t> TrigGlobEffCorr::ImportData::m_hierarchyData

protected

Definition at line 167 of file ImportData.h.

m_hierarchyMeta

std::vector<Hierarchy> TrigGlobEffCorr::ImportData::m_hierarchyMeta

protected

Definition at line 166 of file ImportData.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_parent

TrigGlobalEfficiencyCorrectionTool* TrigGlobEffCorr::ImportData::m_parent

protected

Definition at line 159 of file ImportData.h.

m_triggerDefs

std::map<std::size_t, TrigDef> TrigGlobEffCorr::ImportData::m_triggerDefs

protected

Definition at line 163 of file ImportData.h.

m_triggerThresholds

std::map<std::size_t, float> TrigGlobEffCorr::ImportData::m_triggerThresholds

protected

Definition at line 164 of file ImportData.h.

---

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

• ImportData.h
• ImportData.cxx