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
	SystematicsSvc (const std::string &name, ISvcLocator *pSvcLocator)
	standard constructor More...
virtual StatusCode	initialize () override
	set up/tear down functions More...
virtual StatusCode	finalize () override
virtual std::vector< CP::SystematicSet >	makeSystematicsVector () const override
	get the list of systematics More...
virtual StatusCode	addSystematics (const CP::SystematicSet &recommended, const CP::SystematicSet &affecting) const override
	register a set of recommended and affecting systematics More...
virtual CP::SystematicSet	getObjectSystematics (const std::string &name) const override
	get the systematics for the given object in the event store More...
virtual StatusCode	setObjectSystematics (const std::string &name, const CP::SystematicSet &systematics) const override
	set the systematics for the given object in the event store More...
virtual CP::SystematicSet	getDecorSystematics (const std::string &objectName, const std::string &decorName) const override
	get the systematics for the given object in the event store More...
virtual StatusCode	setDecorSystematics (const std::string &objectName, const std::string &decorName, const CP::SystematicSet &systematics) const override
	set the systematics for the given object in the event store More...
virtual StatusCode	registerCopy (const std::string &fromName, const std::string &toName) const override
	register a (shallow) copy from one object to the next More...
virtual std::string	getCopySource (const std::string &toName) const override
	get a source object name from which a target object has been copied More...
virtual StatusCode	makeSystematicsName (std::string &result, const std::string &name, const CP::SystematicSet &sys) const override
	make the name for the given systematics More...
virtual void	print () const
	Print the state of the service. More...
template<typename T >
void	declareServiceInterface ()
	add the given interface to the list of interfaces More...
virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvi)
	query interface for gaudi More...
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const
	DeclareInterfaceID (CP::ISystematicsSvc, 1, 0)

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 More...
Gaudi::Property< std::string >	m_systematicsRegex {this, "systematicsRegex", "(.*)", "systematics filter regex"}
	the regular expression for filterinf systematics More...
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 More...
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 More...
SystematicSet m_affectingSystematics	ATLAS_THREAD_SAFE
	the list of affecting systematics More...
SystematicSet m_recommendedSystematics	ATLAS_THREAD_SAFE
	the list of recommended systematics More...
std::unordered_map< std::string, CP::SystematicSet > m_objectSystematics	ATLAS_THREAD_SAFE
	the list of per-object systematics More...
std::unordered_map< std::string, CP::SystematicSet > m_decorSystematics	ATLAS_THREAD_SAFE
	the list of per-object-and-decoration systematics More...
std::unordered_map< std::string, std::string > m_copies	ATLAS_THREAD_SAFE
	the map of registered copies More...
std::mutex	m_systematicsMutex
	a mutex for accessing the above mutable members More...
std::vector< std::pair< const InterfaceID &(*)(), void *(*)(AsgService *)> >	m_interfaces
	list of interfaces we have More...

Detailed Description

the canonical implementation of ISystematicsSvc

Definition at line 23 of file SystematicsSvc.h.

Constructor & Destructor Documentation

SystematicsSvc()

CP::SystematicsSvc::SystematicsSvc	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

standard constructor

Guarantee

strong

Failures

out of memory II

Definition at line 28 of file SystematicsSvc.cxx.

    : AsgService (name, pSvcLocator)
  {
    declareServiceInterface<ISystematicsSvc>();
  }

Member Function Documentation

addSystematics()

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

overridevirtual

register a set of recommended and affecting systematics

This is usually obtained from an CP::ISystematicsTool and is used for calculating the list of systematics to use on the fly.

Implements CP::ISystematicsSvc.

Definition at line 104 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;
  }

DeclareInterfaceID()

CP::ISystematicsSvc::DeclareInterfaceID ( CP::ISystematicsSvc  , 1  , 0    )

inherited

declareServiceInterface()

template<typename T >

void asg::AsgService::declareServiceInterface

inherited

add the given interface to the list of interfaces

Definition at line 76 of file AsgService.h.

  {
#ifndef XAOD_STANDALONE
    m_interfaces.emplace_back (T::interfaceID, [] (AsgService *self) -> void* {return dynamic_cast<T*>(self);});
#endif
  }

finalize()

StatusCode CP::SystematicsSvc::finalize ( )

overridevirtual

Reimplemented from asg::AsgService.

Definition at line 265 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

get a source object name from which a target object has been copied

Implements CP::ISystematicsSvc.

Definition at line 218 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

get the systematics for the given object in the event store

Implements CP::ISystematicsSvc.

Definition at line 159 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 ();
  }

getObjectSystematics()

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

overridevirtual

get the systematics for the given object in the event store

Implements CP::ISystematicsSvc.

Definition at line 126 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

set up/tear down functions

Reimplemented from asg::AsgService.

Definition at line 38 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

make the name for the given systematics

Implements CP::ISystematicsSvc.

Definition at line 231 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

get the list of systematics

Implements CP::ISystematicsSvc.

Definition at line 61 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;
  }

msg() [1/2]

MsgStream& AthCommonMsg< Service >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< Service >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< Service >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

print()

void asg::AsgService::print ( ) const

virtualinherited

Print the state of the service.

Implements asg::IAsgService.

Definition at line 48 of file AsgService.cxx.

  {
    ATH_MSG_INFO( "AsgService " << name() << " @ " << this );
    return;
  }

queryInterface()

StatusCode asg::AsgService::queryInterface ( const InterfaceID &  riid, void **  ppvi  )

virtualinherited

query interface for gaudi

Definition at line 57 of file AsgService.cxx.

  {
    for (const auto& interface : m_interfaces)
    {
      if (riid == interface.first())
      {
        *ppvi = interface.second (this);
        addRef();
        return StatusCode::SUCCESS;
      }
    }
    return AsgServiceBase::queryInterface (riid, ppvi);
  }

registerCopy()

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

overridevirtual

register a (shallow) copy from one object to the next

Implements CP::ISystematicsSvc.

Definition at line 202 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

set the systematics for the given object in the event store

Implements CP::ISystematicsSvc.

Definition at line 180 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

set the systematics for the given object in the event store

Implements CP::ISystematicsSvc.

Definition at line 139 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]

SystematicSet m_affectingSystematics CP::SystematicsSvc::ATLAS_THREAD_SAFE

mutableprivate

the list of affecting systematics

Definition at line 104 of file SystematicsSvc.h.

ATLAS_THREAD_SAFE [2/5]

SystematicSet m_recommendedSystematics CP::SystematicsSvc::ATLAS_THREAD_SAFE

mutableprivate

the list of recommended systematics

Definition at line 108 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 112 of file SystematicsSvc.h.

ATLAS_THREAD_SAFE [4/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 116 of file SystematicsSvc.h.

ATLAS_THREAD_SAFE [5/5]

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

mutableprivate

the map of registered copies

Definition at line 120 of file SystematicsSvc.h.

m_interfaces

std::vector<std::pair<const InterfaceID& (*)(),void *(*)(AsgService*)> > asg::AsgService::m_interfaces

privateinherited

list of interfaces we have

Definition at line 68 of file AsgService.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 99 of file SystematicsSvc.h.

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 95 of file SystematicsSvc.h.

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 82 of file SystematicsSvc.h.

m_systematicsMutex

std::mutex CP::SystematicsSvc::m_systematicsMutex

mutableprivate

a mutex for accessing the above mutable members

Definition at line 124 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 86 of file SystematicsSvc.h.

---

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

• SystematicsSvc.h
• SystematicsSvc.cxx