a class managing the property to configure the list of systematics to process More...

#include <SysListHandle.h>

Inheritance diagram for CP::SysListHandle:

Collaboration diagram for CP::SysListHandle:

Public Member Functions
template<typename T >
	SysListHandle (T *owner, const std::string &propertyName="systematicsService", const std::string &propertyDescription="systematics to evaluate")
	standard constructor More...

StatusCode	addHandle (ISysHandleBase &handle)
	register an input handle we are using More...

::StatusCode	initialize ()
	intialize this property More...

bool	isInitialized () const noexcept
	whether initialize has been called successfully More...

const ISystematicsSvc &	service () const
	the service we use More...

const std::vector< CP::SystematicSet > &	systematicsVector () const
	the list of systematics to loop over More...

bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object. More...

MsgStream &	msg () const
	The standard message stream. More...

MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream. More...


StatusCode	addSystematics (const CP::SystematicSet &recommended, const CP::SystematicSet &affecting)
	register a set of affecting variables for the current algorithm (usually obtained from an CP::ISystematicsTool) More...

StatusCode	addSystematics (const IReentrantSystematicsTool &tool)

Private Member Functions
StatusCode	fillSystematicsVector ()

Private Attributes
ServiceHandle< ISystematicsSvc >	m_systematicsService {"SystematicsSvc", ""}
	the handle for the systematics service More...

std::string	m_affectingFilter
	an (optional) filter to remove affecting systematics More...

std::vector< ISysHandleBase * >	m_sysHandles
	the list of systematics handles we have More...

CP::SystematicSet	m_affecting
	this set of affecting systematics More...

std::vector< CP::SystematicSet >	m_systematicsVector
	the value of systematicsVector More...

bool	m_isInitialized = false
	the value of isInitialized More...

std::function< MsgStream &()>	m_msg
	the message stream we use More...

Detailed Description

a class managing the property to configure the list of systematics to process

Definition at line 32 of file SysListHandle.h.

Constructor & Destructor Documentation

◆ SysListHandle()

template<typename T >

CP::SysListHandle::SysListHandle	(	T *	owner,
		const std::string &	propertyName = `"systematicsService"`,
		const std::string &	propertyDescription = `"systematics to evaluate"`
	)

standard constructor

Member Function Documentation

◆ addHandle()

StatusCode CP::SysListHandle::addHandle ( ISysHandleBase & handle )

register an input handle we are using

This is currently a no-op, but it could be useful for a variety of future directions we could take the systematics handling.

Precondition: !isInitialized()

Definition at line 28 of file SysListHandle.cxx.

   {
     if (isInitialized())
     {
       ANA_MSG_ERROR ("trying to add/initialize data handle after initializing SysListHandle");
       return StatusCode::FAILURE;
     }
     if (handle.empty())
     {
       ANA_MSG_ERROR ("trying to add/initialize empty data handle");
       return StatusCode::FAILURE;
     }
     m_sysHandles.push_back (&handle);
     return StatusCode::SUCCESS;
   }

◆ addSystematics() [1/2]

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

register a set of affecting variables for the current algorithm (usually obtained from an CP::ISystematicsTool)

This is currently a no-op, but it could be useful for a variety of future directions we could take the systematics handling (or at least as a cross check of those).

Precondition: !isInitialized()

Definition at line 47 of file SysListHandle.cxx.

   {
     assert (!isInitialized());
     ANA_CHECK (m_systematicsService->addSystematics (recommended, affecting));
     m_affecting.insert (affecting);
     return StatusCode::SUCCESS;
   }

◆ addSystematics() [2/2]

StatusCode CP::SysListHandle::addSystematics ( const IReentrantSystematicsTool & tool )

Definition at line 59 of file SysListHandle.cxx.

   {
     return addSystematics (tool.recommendedSystematics(),
                            tool.affectingSystematics());
   }

◆ fillSystematicsVector()

StatusCode CP::SysListHandle::fillSystematicsVector ( )

private

Definition at line 104 of file SysListHandle.cxx.

   {
     assert (m_systematicsVector.empty());
  
     std::unordered_set<CP::SystematicSet> knownSys;
  
     for (const auto& sys : m_systematicsService->makeSystematicsVector())
     {
       CP::SystematicSet filtered;
       ANA_CHECK (SystematicSet::filterForAffectingSystematics (sys, m_affecting, filtered));
       if (knownSys.find (filtered) == knownSys.end())
       {
         m_systematicsVector.push_back (filtered);
         knownSys.insert (filtered);
       }
     }
     return StatusCode::SUCCESS;
   }

◆ initialize()

StatusCode CP::SysListHandle::initialize ( )

intialize this property

This should be called exactly once during initialize of the owning algorithm.

Definition at line 68 of file SysListHandle.cxx.

   {
     for (ISysHandleBase *handle : m_sysHandles)
       m_affecting.insert (handle->getInputAffecting (*m_systematicsService));
     if (!m_affectingFilter.empty())
     {
       std::regex filter (m_affectingFilter);
       auto affecting = std::move (m_affecting);
       m_affecting.clear ();
       for (auto& sys : affecting)
       {
         if (!std::regex_match (sys.basename(), filter))
         {
           m_affecting.insert (sys);
         }
       }
     }
     ANA_CHECK (fillSystematicsVector());
     for (ISysHandleBase *handle : m_sysHandles)
       ANA_CHECK (handle->fillSystematics (*m_systematicsService, m_affecting, m_systematicsVector));
     m_isInitialized = true;
     return StatusCode::SUCCESS;
   }

◆ isInitialized()

bool CP::SysListHandle::isInitialized ( ) const

noexcept

whether initialize has been called successfully

◆ msg() [1/2]

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

inherited

The standard message stream.

Returns: A reference to the default message stream of this object.

Definition at line 24 of file AsgMessagingForward.cxx.

   {
     return m_msg();
   }

◆ msg() [2/2]

MsgStream & asg::AsgMessagingForward::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 29 of file AsgMessagingForward.cxx.

   {
     MsgStream& msg = m_msg ();
     msg << lvl;
     return msg;
   }

◆ msgLvl()

bool asg::AsgMessagingForward::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 11 of file AsgMessagingForward.cxx.

   {
     MsgStream& msg = m_msg();
     if (msg.level() <= lvl)
     {
       msg << lvl;
       return true;
     } else
     {
       return false;
     }
   }

◆ service()

const ISystematicsSvc& CP::SysListHandle::service ( ) const

the service we use

◆ systematicsVector()

const std::vector< CP::SystematicSet > & CP::SysListHandle::systematicsVector ( ) const

the list of systematics to loop over

The way used should use this is as:

for (const auto& sys : m_systematicsList.systematicsVector())
{
  ...
}

The important part is to use const auto& instead of const CP::SystematicSet& here, as in the future this may be updated to be a vector of something other than a CP::SystematicSet (still convertible to const CP::SystematicSet& though).

Definition at line 95 of file SysListHandle.cxx.

   {
     assert (isInitialized());
     return m_systematicsVector;
   }

Member Data Documentation

◆ m_affecting

CP::SystematicSet CP::SysListHandle::m_affecting

private

this set of affecting systematics

Definition at line 126 of file SysListHandle.h.

◆ m_affectingFilter

std::string CP::SysListHandle::m_affectingFilter

private

an (optional) filter to remove affecting systematics

Definition at line 118 of file SysListHandle.h.

◆ m_isInitialized

bool CP::SysListHandle::m_isInitialized = false

private

the value of isInitialized

Definition at line 134 of file SysListHandle.h.

◆ m_msg

std::function<MsgStream& ()> asg::AsgMessagingForward::m_msg

privateinherited

the message stream we use

This used to be a simple pointer to the MsgStream itself, but in AthenaMT the actual object used is local to the thread. So instead of pointing to it directly we are now using a function to look it up, which will get the thread-local object.

Definition at line 77 of file AsgMessagingForward.h.

◆ m_sysHandles

std::vector<ISysHandleBase*> CP::SysListHandle::m_sysHandles

private

the list of systematics handles we have

Definition at line 122 of file SysListHandle.h.

◆ m_systematicsService

ServiceHandle<ISystematicsSvc> CP::SysListHandle::m_systematicsService {"SystematicsSvc", ""}

private

the handle for the systematics service

Definition at line 114 of file SysListHandle.h.

◆ m_systematicsVector

std::vector<CP::SystematicSet> CP::SysListHandle::m_systematicsVector

private

the value of systematicsVector

Definition at line 130 of file SysListHandle.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SysListHandle()

Member Function Documentation

◆ addHandle()

◆ addSystematics() [1/2]

◆ addSystematics() [2/2]

◆ fillSystematicsVector()

◆ initialize()

◆ isInitialized()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ service()

◆ systematicsVector()

Member Data Documentation

◆ m_affecting

◆ m_affectingFilter

◆ m_isInitialized

◆ m_msg

◆ m_sysHandles

◆ m_systematicsService

◆ m_systematicsVector