CP::SystematicsSvc Class Reference

the canonical implementation of ISystematicsSvc More...

#include <SystematicsSvc.h>

Inheritance diagram for CP::SystematicsSvc:

Collaboration diagram for CP::SystematicsSvc:

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual std::vector< CP::SystematicSet >	makeSystematicsVector () const override
virtual StatusCode	addSystematics (const CP::SystematicSet &recommended, const CP::SystematicSet &affecting) const override
virtual CP::SystematicSet	getObjectSystematics (const std::string &name) const override
virtual StatusCode	setObjectSystematics (const std::string &name, const CP::SystematicSet &systematics) const override
virtual CP::SystematicSet	getDecorSystematics (const std::string &objectName, const std::string &decorName) const override
virtual StatusCode	setDecorSystematics (const std::string &objectName, const std::string &decorName, const CP::SystematicSet &systematics) const override
virtual StatusCode	registerCopy (const std::string &fromName, const std::string &toName) const override
virtual std::string	getCopySource (const std::string &toName) const override
virtual std::vector< std::string >	getObjectDecorations (const std::string &name) const override
virtual StatusCode	makeSystematicsName (std::string &result, const std::string &name, const CP::SystematicSet &sys) const override

Private Attributes
Gaudi::Property< std::vector< std::string > >	m_systematicsList {this, "systematicsList", {}, "the list of systematics to run"}
	the names of the systematics to request
Gaudi::Property< std::string >	m_systematicsRegex {this, "systematicsRegex", "(.*)", "systematics filter regex"}
	the regular expression for filterinf systematics
Gaudi::Property< float >	m_sigmaRecommended {this, "sigmaRecommended", 0, "the sigma with which to run recommended systematics"}
	load all recommended systematics at the given number of sigmas
Gaudi::Property< std::string >	m_nominalSystematicsName {this, "nominalSystematicsName", "NOSYS", "the name to use for the nominal systematic (instead of the empty string)"}
	nominal systematics name
SystematicSet m_affectingSystematics	ATLAS_THREAD_SAFE
	the list of affecting systematics
SystematicSet m_recommendedSystematics	ATLAS_THREAD_SAFE
	the list of recommended systematics
std::unordered_map< std::string, CP::SystematicSet > m_objectSystematics	ATLAS_THREAD_SAFE
	the list of per-object systematics
std::unordered_map< std::string, CP::SystematicSet > m_decorSystematics	ATLAS_THREAD_SAFE
	the list of per-object-and-decoration systematics
std::unordered_map< std::string, std::string > m_copies	ATLAS_THREAD_SAFE
	the map of registered copies
std::mutex	m_systematicsMutex
	a mutex for accessing the above mutable members

Detailed Description

the canonical implementation of ISystematicsSvc

Definition at line 23 of file SystematicsSvc.h.

Member Function Documentation

addSystematics()

StatusCode CP::SystematicsSvc::addSystematics ( const CP::SystematicSet & recommended, const CP::SystematicSet & affecting ) const

overridevirtual

Definition at line 95 of file SystematicsSvc.cxx.

  {
    std::lock_guard<std::mutex> lock (m_systematicsMutex);
 
    for (const CP::SystematicVariation& mysys : recommended)
    {
      if (affecting.find (mysys) == affecting.end())
      {
        ANA_MSG_ERROR ("systematic is only registered as recommended, not affecting: " << mysys);
        return StatusCode::FAILURE;
      }
    }
 
    m_affectingSystematics.insert (affecting);
    m_recommendedSystematics.insert (recommended);
    return StatusCode::SUCCESS;
  }

finalize()

StatusCode CP::SystematicsSvc::finalize ( )

overridevirtual

Definition at line 288 of file SystematicsSvc.cxx.

  {
    if (m_systematicsList.empty()) {
      ANA_MSG_INFO ("no systematics were run.");
    }
    else{
      for (const CP::SystematicVariation& mysys : m_affectingSystematics)
    {
      // this logic checks whether a systematic is recommended and
      // affecting, or only affecting.  if it is only the later, it
      // reports the systematic in parenthesis to set it apart.
      if (m_recommendedSystematics.find (mysys) == m_recommendedSystematics.end())
        ANA_MSG_INFO ("found systematic: (" << mysys << ")");
      else
        ANA_MSG_INFO ("found systematic: " << mysys);
    }
 
      if(m_systematicsRegex!=".*") {
    ANA_MSG_INFO("Systematics regex '" << m_systematicsRegex << "' matched:");
    for(const CP::SystematicSet& mysys : makeSystematicsVector()) {
          ANA_MSG_INFO ("  '" << mysys.name() << "'");
    }
      }
    }
    return StatusCode::SUCCESS;
  }

getCopySource()

std::string CP::SystematicsSvc::getCopySource ( const std::string & toName ) const

overridevirtual

Definition at line 209 of file SystematicsSvc.cxx.

  {
    std::lock_guard<std::mutex> lock (m_systematicsMutex);
    auto iter = m_copies.find (toName);
    if (iter == m_copies.end())
      return "";
    else
      return iter->second;
  }

getDecorSystematics()

CP::SystematicSet CP::SystematicsSvc::getDecorSystematics ( const std::string & objectName, const std::string & decorName ) const

overridevirtual

Definition at line 150 of file SystematicsSvc.cxx.

  {
    const std::string name = objectName + "." + decorName;
    std::unique_lock<std::mutex> lock (m_systematicsMutex);
    auto iter = m_decorSystematics.find (name);
    if (iter != m_decorSystematics.end())
      return iter->second;
    auto jter = m_copies.find (objectName);
    if (jter != m_copies.end())
    {
      const std::string& copyName = jter->second;
      lock.unlock();
      return getDecorSystematics (copyName, decorName);
    }
    return CP::SystematicSet ();
  }

getObjectDecorations()

std::vector< std::string > CP::SystematicsSvc::getObjectDecorations ( const std::string & name ) const

overridevirtual

Definition at line 222 of file SystematicsSvc.cxx.

  {
    std::vector<std::string> result;
    std::unique_lock<std::mutex> lock (m_systematicsMutex);
 
    // First get decorations from the copy source (if any)
    auto iter = m_copies.find (name);
    if (iter != m_copies.end())
    {
      const std::string copyName = iter->second;
      lock.unlock();
      result = getObjectDecorations (copyName);
      lock.lock();
    }
 
    // Then add decorations registered directly on this object
    const std::string prefix = name + ".";
    for (const auto& entry : m_decorSystematics)
    {
      if (entry.first.compare(0, prefix.size(), prefix) == 0)
      {
        std::string decor = entry.first.substr(prefix.size());
        if (std::find(result.begin(), result.end(), decor) == result.end())
          result.push_back (std::move(decor));
      }
    }
    return result;
  }

getObjectSystematics()

CP::SystematicSet CP::SystematicsSvc::getObjectSystematics ( const std::string & name ) const

overridevirtual

Definition at line 117 of file SystematicsSvc.cxx.

  {
    std::lock_guard<std::mutex> lock (m_systematicsMutex);
    auto iter = m_objectSystematics.find (name);
    if (iter != m_objectSystematics.end())
      return iter->second;
    else
      return CP::SystematicSet ();
  }

initialize()

StatusCode CP::SystematicsSvc::initialize ( )

overridevirtual

Definition at line 29 of file SystematicsSvc.cxx.

  {
    if (!std::isfinite (m_sigmaRecommended) ||
        m_sigmaRecommended < 0)
    {
      ANA_MSG_ERROR ("invalid value for sigmaRecommended: " << m_sigmaRecommended);
      return StatusCode::FAILURE;
    }
 
    if (m_sigmaRecommended != 0)
    {
      if (!m_systematicsList.empty())
      {
        ANA_MSG_ERROR ("can't specify both sigmaRecommended and systematicsList");
        return StatusCode::FAILURE;
      }
    }
    return StatusCode::SUCCESS;
  }

makeSystematicsName()

StatusCode CP::SystematicsSvc::makeSystematicsName ( std::string & result, const std::string & name, const CP::SystematicSet & sys ) const

overridevirtual

Definition at line 254 of file SystematicsSvc.cxx.

  {
    if (name.empty())
    {
      ANA_MSG_ERROR ("not allowed to make systematic name for empty string");
      return StatusCode::FAILURE;
    }
 
    result = name;
 
    const auto sysSplit = result.find ("%SYS%");
    if (sysSplit == std::string::npos)
    {
      if (!sys.empty())
      {
        ANA_MSG_ERROR ("can't set systematics on name without \"%SYS%\": \"" << name << "\" sys=" << sys.name());
        return StatusCode::FAILURE;
      }
    } else
    {
      std::string sysName = sys.name();
      if (sysName.empty())
        sysName = m_nominalSystematicsName;
      result.replace (sysSplit, 5, sysName);
    }
 
    return StatusCode::SUCCESS;
  }

makeSystematicsVector()

std::vector< CP::SystematicSet > CP::SystematicsSvc::makeSystematicsVector ( ) const

overridevirtual

Definition at line 52 of file SystematicsSvc.cxx.

  {
    std::lock_guard<std::mutex> lock (m_systematicsMutex);
    std::vector<CP::SystematicSet> systematicsVector;
 
    if (m_sigmaRecommended != 0)
    {
      assert (m_sigmaRecommended > 0);
 
      CP::MakeSystematicsVector sys;
      sys.setSigma (m_sigmaRecommended);
      sys.calc (m_recommendedSystematics);
 
      std::regex expr (m_systematicsRegex.value());
      for (const CP::SystematicSet& mysys : sys.result(""))
      {
        if (!regex_match (mysys.name(), expr))
        {
          ANA_MSG_DEBUG ("skipping systematic: " << mysys.name());
        } else {
          ANA_MSG_DEBUG ("configuring systematic: " << mysys.name());
          systematicsVector.push_back (mysys);
        }
      }
    } else if (m_systematicsList.empty())
    {
      // take an empty property as running just the central
      // systematics set.  implication is that you can't really run
      // doing nothing, but that ought to be Ok.
      systematicsVector.push_back (CP::SystematicSet ());
    } else
    {
      for (const std::string& sysName : m_systematicsList)
        systematicsVector.push_back (CP::SystematicSet (sysName));
    }
 
    assert (!systematicsVector.empty());
    return systematicsVector;
  }

registerCopy()

StatusCode CP::SystematicsSvc::registerCopy ( const std::string & fromName, const std::string & toName ) const

overridevirtual

Definition at line 193 of file SystematicsSvc.cxx.

  {
    std::lock_guard<std::mutex> lock (m_systematicsMutex);
    auto emplace_result = m_copies.try_emplace (toName, fromName);
    if (emplace_result.second == false)
    {
      ANA_MSG_ERROR ("duplicate copy registered for name " << toName);
      return StatusCode::FAILURE;
    }
    return StatusCode::SUCCESS;
  }

setDecorSystematics()

StatusCode CP::SystematicsSvc::setDecorSystematics ( const std::string & objectName, const std::string & decorName, const CP::SystematicSet & systematics ) const

overridevirtual

Definition at line 171 of file SystematicsSvc.cxx.

  {
    const std::string name = objectName + "." + decorName;
    auto mysystematics = systematics;
    std::lock_guard<std::mutex> lock (m_systematicsMutex);
    for (const CP::SystematicVariation& mysys : systematics)
    {
      if (m_affectingSystematics.find (mysys) == m_affectingSystematics.end())
      {
        ANA_MSG_ERROR ("systematic is set as object systematic, but not affecting: " << mysys);
        return StatusCode::FAILURE;
      }
    }
    m_decorSystematics[name] = std::move (mysystematics);
    return StatusCode::SUCCESS;
  }

setObjectSystematics()

StatusCode CP::SystematicsSvc::setObjectSystematics ( const std::string & name, const CP::SystematicSet & systematics ) const

overridevirtual

Definition at line 130 of file SystematicsSvc.cxx.

  {
    auto mysystematics = systematics;
    std::lock_guard<std::mutex> lock (m_systematicsMutex);
    for (const CP::SystematicVariation& mysys : systematics)
    {
      if (m_affectingSystematics.find (mysys) == m_affectingSystematics.end())
      {
        ANA_MSG_ERROR ("systematic is set as object systematic, but not affecting: " << mysys);
        return StatusCode::FAILURE;
      }
    }
    m_objectSystematics[name] = std::move (mysystematics);
    return StatusCode::SUCCESS;
  }

Member Data Documentation

ATLAS_THREAD_SAFE [1/5]

std::unordered_map<std::string,std::string> m_copies CP::SystematicsSvc::ATLAS_THREAD_SAFE

mutableprivate

the map of registered copies

Definition at line 109 of file SystematicsSvc.h.

ATLAS_THREAD_SAFE [2/5]

std::unordered_map<std::string,CP::SystematicSet> m_decorSystematics CP::SystematicsSvc::ATLAS_THREAD_SAFE

mutableprivate

the list of per-object-and-decoration systematics

Definition at line 105 of file SystematicsSvc.h.

ATLAS_THREAD_SAFE [3/5]

std::unordered_map<std::string,CP::SystematicSet> m_objectSystematics CP::SystematicsSvc::ATLAS_THREAD_SAFE

mutableprivate

the list of per-object systematics

Definition at line 101 of file SystematicsSvc.h.

ATLAS_THREAD_SAFE [4/5]

SystematicSet m_recommendedSystematics CP::SystematicsSvc::ATLAS_THREAD_SAFE

mutableprivate

the list of recommended systematics

Definition at line 97 of file SystematicsSvc.h.

ATLAS_THREAD_SAFE [5/5]

SystematicSet m_affectingSystematics CP::SystematicsSvc::ATLAS_THREAD_SAFE

mutableprivate

the list of affecting systematics

Definition at line 93 of file SystematicsSvc.h.

m_nominalSystematicsName

Gaudi::Property<std::string> CP::SystematicsSvc::m_nominalSystematicsName {this, "nominalSystematicsName", "NOSYS", "the name to use for the nominal systematic (instead of the empty string)"}

private

nominal systematics name

Definition at line 88 of file SystematicsSvc.h.

{this, "nominalSystematicsName", "NOSYS", "the name to use for the nominal systematic (instead of the empty string)"};

m_sigmaRecommended

Gaudi::Property<float> CP::SystematicsSvc::m_sigmaRecommended {this, "sigmaRecommended", 0, "the sigma with which to run recommended systematics"}

private

load all recommended systematics at the given number of sigmas

The idea here is that this allows to run a simple analysis by itself without having to generate the list of systematics manually.

Definition at line 84 of file SystematicsSvc.h.

{this, "sigmaRecommended", 0, "the sigma with which to run recommended systematics"};

m_systematicsList

Gaudi::Property<std::vector<std::string> > CP::SystematicsSvc::m_systematicsList {this, "systematicsList", {}, "the list of systematics to run"}

private

the names of the systematics to request

Definition at line 71 of file SystematicsSvc.h.

{this, "systematicsList", {}, "the list of systematics to run"};

m_systematicsMutex

std::mutex CP::SystematicsSvc::m_systematicsMutex

mutableprivate

a mutex for accessing the above mutable members

Definition at line 113 of file SystematicsSvc.h.

m_systematicsRegex

Gaudi::Property<std::string> CP::SystematicsSvc::m_systematicsRegex {this, "systematicsRegex", "(.*)", "systematics filter regex"}

private

the regular expression for filterinf systematics

Definition at line 75 of file SystematicsSvc.h.

{this, "systematicsRegex", "(.*)", "systematics filter regex"};

---

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

• SystematicsSvc.h
• SystematicsSvc.cxx