an object that can create a AnaAlgorithm More...

#include <AnaAlgorithmConfig.h>

Inheritance diagram for EL::AnaAlgorithmConfig:

Collaboration diagram for EL::AnaAlgorithmConfig:

Public Member Functions
	AnaAlgorithmConfig ()
	standard constructor More...

	AnaAlgorithmConfig (const std::string &val_typeAndName)
	initializing constructor More...

	AnaAlgorithmConfig (const AsgComponentConfig &val_config)
	initializing constructor More...

virtual	~AnaAlgorithmConfig ()=default
	Virtual destructor, to make PyROOT happy. More...

bool	useXAODs () const noexcept
	whether we use XAODs More...

void	setUseXAODs (bool val_useXAODs) noexcept
	set the value of useXAODs More...

bool	isPublicTool () const noexcept
	whether we are really a public tool More...

void	setIsPublicTool (bool val_isPublicTool) noexcept
	set the value of isPublicTool More...

::StatusCode	makeAlgorithm (std::unique_ptr< AnaAlgorithm > &algorithm, const AlgorithmWorkerData &workerData) const
	make an algorithm from this configuration More...

bool	empty () const noexcept
	whether all properties are unset More...

const std::string &	type () const noexcept
	the type of the component More...

void	setType (const std::string &val_type)
	set the value of type More...

const std::string &	name () const noexcept
	the name of the component More...

void	setName (const std::string &val_name)
	set the value of name More...

std::string	typeAndName () const
	get type and name at the same time More...

void	setTypeAndName (const std::string &val_typeAndName)
	set type and name at the same time More...

template<typename T >
StatusCode	setProperty (const std::string &name, const T &value)
	set the given property More...

void	setPropertyFromString (const std::string &name, const std::string &value)
	set a given property from a string value More...

StatusCode	createPrivateTool (const std::string &name, const std::string &toolType)
	create a private tool of the given name and type More...

StatusCode	addPrivateTool (const std::string &name, AsgComponentConfig toolConfig)
	add a private tool from the given configuration More...

std::string	createPrivateToolInArray (const std::string &name, const std::string &toolType)
	the array version of createPrivateTool More...

std::string	addPrivateToolInArray (const std::string &name, AsgComponentConfig toolConfig)
	the array version of addPrivateTool More...

StatusCode	configureComponentExpert (const std::string &prefix, bool nestedNames) const
	add component configuration to configuration service (expert only) More...

Private Member Functions
StatusCode	checkTypeName (bool nestedNames) const
	check that the type and name members have the correct format More...

Private Attributes
bool	m_useXAODs = true
	the value of useXAODs More...

bool	m_isPublicTool {false}
	the value of isPublicTool More...

std::string	m_type
	the value of type More...

std::string	m_name
	the value of name More...

std::map< std::string, details::AsgComponentPrivateToolConfig >	m_privateTools
	the map of (private) tools to create More...

std::map< std::string, std::vector< std::string > >	m_toolArrays
	the map of (private) tool handle arrays to manage, and the tools they contain More...

std::map< std::string, std::string >	m_propertyValues
	the map of property values More...

Detailed Description

an object that can create a AnaAlgorithm

Definition at line 28 of file AnaAlgorithmConfig.h.

Constructor & Destructor Documentation

◆ AnaAlgorithmConfig() [1/3]

EL::AnaAlgorithmConfig::AnaAlgorithmConfig ( )

standard constructor

Guarantee: strong

Failures: out of memory I

Definition at line 26 of file AnaAlgorithmConfig.cxx.

28 {

29 }

◆ AnaAlgorithmConfig() [2/3]

EL::AnaAlgorithmConfig::AnaAlgorithmConfig ( const std::string & val_typeAndName )

explicit

initializing constructor

Guarantee: strong

Failures: out of memory II

Definition at line 33 of file AnaAlgorithmConfig.cxx.

     : AsgComponentConfig (val_typeAndName)
   {
   }

◆ AnaAlgorithmConfig() [3/3]

EL::AnaAlgorithmConfig::AnaAlgorithmConfig ( const AsgComponentConfig & val_config )

explicit

initializing constructor

Guarantee: strong

Failures: out of memory II

Definition at line 41 of file AnaAlgorithmConfig.cxx.

     : AsgComponentConfig (val_config)
   {
   }

◆ ~AnaAlgorithmConfig()

virtual EL::AnaAlgorithmConfig::~AnaAlgorithmConfig ( )

virtualdefault

Virtual destructor, to make PyROOT happy.

Without it ROOT 6.22+ does not allow Python classes to inherit from this type.

Member Function Documentation

◆ accessSubtool()

AsgComponentConfig::AccessSubtoolData asg::AsgComponentConfig::accessSubtool	(	const std::string &	name,
		std::size_t	split
	)

privateinherited

Definition at line 239 of file AsgComponentConfig.cxx.

   {
     AccessSubtoolData result;
     auto subtool = m_privateTools.find (name.substr (0, split));
     if (subtool == m_privateTools.end())
       throw std::runtime_error ("trying to access unknown private tool: " + name.substr (0, split));
     result.config = &(subtool->second.m_config);
     result.prefix = name.substr (0, split + 1);
     result.name = name.substr (split + 1);
     return result;
   }

◆ addPrivateTool()

StatusCode asg::AsgComponentConfig::addPrivateTool	(	const std::string &	name,
		AsgComponentConfig	toolConfig
	)

inherited

add a private tool from the given configuration

This will ignore the name set in toolConfig and use whatever name is given instead.

Guarantee: basic

Failures: out of memory II

Definition at line 167 of file AsgComponentConfig.cxx.

   {
     using namespace msgComponentConfig;
  
     auto split = name.find ('.');
     if (split == std::string::npos)
     {
       toolConfig.setName (name);
       m_privateTools[name] = {toolConfig, ""};
       return StatusCode::SUCCESS;
     } else
     {
       auto subtool = accessSubtool (name, split);
       return subtool.config->addPrivateTool (subtool.name, std::move (toolConfig));
     }
   }

◆ addPrivateToolInArray()

std::string asg::AsgComponentConfig::addPrivateToolInArray	(	const std::string &	name,
		AsgComponentConfig	toolConfig
	)

inherited

the array version of addPrivateTool

This will ignore the name set in toolConfig and use whatever name is given instead.

Guarantee: basic

Failures: out of memory II

Definition at line 188 of file AsgComponentConfig.cxx.

   {
     using namespace msgComponentConfig;
  
     auto split = name.find ('.');
     if (split == std::string::npos)
     {
       auto& arrayData = m_toolArrays[name];
       auto myname = makeArrayName (name, arrayData.size());
       toolConfig.setName (myname);
       m_privateTools[myname] = {toolConfig, name};
       arrayData.push_back (myname);
       return myname;
     } else
     {
       auto subtool = accessSubtool (name, split);
       return subtool.prefix + subtool.config
         ->addPrivateToolInArray (subtool.name, std::move (toolConfig));
     }
   }

◆ checkTypeName()

StatusCode asg::AsgComponentConfig::checkTypeName ( bool nestedNames ) const

privateinherited

check that the type and name members have the correct format

Guarantee: strong

Failures: type or name doesn't have proper format

Definition at line 213 of file AsgComponentConfig.cxx.

   {
     using namespace msgComponentConfig;
  
     std::regex typeExpr ("[A-Za-z_][A-Za-z0-9_]*(::[A-Za-z_][A-Za-z0-9_]*)*");
     if (!std::regex_match (m_type, typeExpr))
     {
       ANA_MSG_ERROR ("type \"" << m_type << "\" does not match format expression");
       return StatusCode::FAILURE;
     }
     std::regex nameExpr;
     if (nestedNames)
       nameExpr = std::regex ("[A-Za-z_][A-Za-z0-9_]*(\\.[A-Za-z_][A-Za-z0-9_]*)*(@[0-9]+)?");
     else
       nameExpr = std::regex ("[A-Za-z_][A-Za-z0-9_]*(@[0-9]+)?");
     if (!std::regex_match (m_name, nameExpr))
     {
       ANA_MSG_ERROR ("name \"" << m_name << "\" does not match format expression");
       return StatusCode::FAILURE;
     }
     return StatusCode::SUCCESS;
   }

◆ configureComponentExpert()

StatusCode asg::AsgComponentConfig::configureComponentExpert	(	const std::string &	prefix,
		bool	nestedNames
	)		const

inherited

add component configuration to configuration service (expert only)

In Athena we are not creating components (we leave that to the proper Athena services), but instead we load the configuration values up first, then ask for the component to be created the normal way. This makes sure that if we dump the configuration it will include this component, and as a bonus it avoids the whole issue of having to deal with Athena factory functions.

Guarantee: basic

Failures: configuration errors

Definition at line 364 of file AsgComponentConfig.cxx.

   {
     using namespace msgComponentConfig;
  
     ANA_CHECK (checkTypeName (nestedNames));
  
     ServiceHandle<Gaudi::Interfaces::IOptionsSvc> joSvc("JobOptionsSvc","AsgComponentConfig");
     ANA_CHECK (joSvc.retrieve());
  
     for (const auto& tool : m_privateTools)
     {
       ANA_CHECK (tool.second.m_config.configureComponentExpert (prefix + m_name + ".", true));
       if (tool.second.m_propName.empty())
       {
         std::string toolPath = prefix + m_name + "." + tool.first;
         joSvc->set (toolPath, tool.second.m_config.typeAndName());
       }
     }
  
     for (const auto& toolArray : m_toolArrays)
     {
       std::vector<std::string> valueArray;
       for (const auto& tool : toolArray.second)
       {
         auto toolConfig = m_privateTools.find (tool);
         if (toolConfig == m_privateTools.end())
         {
           ANA_MSG_ERROR ("Couldn't find private tool with name \"" << tool << "\"");
           ANA_MSG_ERROR ("This is an internal inconsistency!");
           return StatusCode::FAILURE;
         }
         valueArray.push_back (toolConfig->second.m_config.typeAndName());
       }
       std::string valueString = Gaudi::Utils::toString (valueArray);
       std::string propertyPath = prefix + m_name + "." + toolArray.first;
       joSvc->set (propertyPath, valueString);
     }
  
     for (const auto& property : m_propertyValues)
     {
       std::string propertyPath = prefix + m_name + "." + property.first;
       joSvc->set (propertyPath, property.second);
     }
  
     return StatusCode::SUCCESS;
   }

◆ createPrivateTool()

StatusCode asg::AsgComponentConfig::createPrivateTool	(	const std::string &	name,
		const std::string &	toolType
	)

inherited

create a private tool of the given name and type

This is the only way you can configure tool properties through AsgComponentConfig: You need to add it the tool to the component configuration and then you can set individual properties on the tool, using the property name "tool.property".

If you want to add a subtool for a tool, you can do this by calling it "tool.subtool". Note that you will have to create both the tool and the subtool this way, i.e. you can't configure a subtool without also configuring the tool that owns it.

You can apply this to tools held by either ToolHandle or asg::AnaToolHandle, but if you configure a tool held by an AnaToolHandle this way it will completely replace teh tool configuration done in the component itself.

The calling convention is somewhat inverted compared to setTypeAndName() calls, but otherwise they would be inverted compared to the setProperty() calls. :(

Guarantee: strong

Failures: out of memory II

Definition at line 149 of file AsgComponentConfig.cxx.

   {
     return addPrivateTool (name, AsgComponentConfig(toolType + "/" + name));
   }

◆ createPrivateToolInArray()

std::string asg::AsgComponentConfig::createPrivateToolInArray	(	const std::string &	name,
		const std::string &	toolType
	)

inherited

the array version of createPrivateTool

This returns the actual name of the tool to allow setting properties on it.

Guarantee: basic

Failures: out of memory II

Definition at line 158 of file AsgComponentConfig.cxx.

   {
     return addPrivateToolInArray (name, AsgComponentConfig(toolType + "/" + name));
   }

◆ empty()

bool asg::AsgComponentConfig::empty ( ) const

noexceptinherited

whether all properties are unset

Guarantee: no-fail

Definition at line 63 of file AsgComponentConfig.cxx.

   {
     return
       m_type.empty() && m_name.empty() &&
       m_privateTools.empty() && m_propertyValues.empty();
   }

◆ isPublicTool()

bool EL::AnaAlgorithmConfig::isPublicTool ( ) const

noexcept

whether we are really a public tool

Guarantee: no-fail

Definition at line 65 of file AnaAlgorithmConfig.cxx.

   {
     return m_isPublicTool;
   }

◆ makeAlgorithm()

StatusCode EL::AnaAlgorithmConfig::makeAlgorithm	(	std::unique_ptr< AnaAlgorithm > &	algorithm,
		const AlgorithmWorkerData &	workerData
	)		const

make an algorithm from this configuration

Note that generally users won't call this function. The typical workflow is to fully configure this object and then hand it over to EventLoop which will take care of creating the actual algorithm.

An exception may be unit tests. If this turns out to be too cumbersome for unit testing we may need to revisit it at that point. For now it is unclear whether we'll even be able to do algorithm unit testing either way.

Guarantee: strong

Failures: configuration errors
algorithm creation/initialization errors

Definition at line 81 of file AnaAlgorithmConfig.cxx.

   {
     using namespace msgAlgorithmConfig;
  
     if (m_isPublicTool == false)
     {
       ANA_CHECK (makeComponentExpert (algorithm, "new %1% (\"%2%\", nullptr)", true, ""));
       algorithm->setHistogramWorker (workerData.m_histogramWorker);
       algorithm->setTreeWorker (workerData.m_treeWorker);
       algorithm->setFilterWorker (workerData.m_filterWorker);
       algorithm->setWk (workerData.m_wk);
       if (workerData.m_evtStore)
         algorithm->setEvtStore (workerData.m_evtStore);
       ANA_CHECK (algorithm->sysInitialize());
     } else
     {
       std::unique_ptr<asg::AsgTool> tool;
       ANA_CHECK (makeComponentExpert (tool, "new %1% (\"%2%\")", true, ""));
       ANA_CHECK (tool->initialize());
  
       AnaAlgorithmConfig dummyAlg ("EL::AnaAlgorithm/DummyAlg." + name());
       ANA_CHECK (dummyAlg.makeAlgorithm (algorithm, workerData));
       algorithm->addCleanup (std::move (tool));
     }
  
     ANA_MSG_DEBUG ("Created component of type " << type());
     return StatusCode::SUCCESS;
   }

◆ name()

const std::string & asg::AsgComponentConfig::name ( ) const

noexceptinherited

the name of the component

Guarantee: no-fail

Definition at line 89 of file AsgComponentConfig.cxx.

   {
     return m_name;
   }

◆ setIsPublicTool()

void EL::AnaAlgorithmConfig::setIsPublicTool ( bool val_isPublicTool )

noexcept

set the value of isPublicTool

Guarantee: no-fail

Definition at line 73 of file AnaAlgorithmConfig.cxx.

   {
     m_isPublicTool = val_isPublicTool;
   }

◆ setName()

void asg::AsgComponentConfig::setName ( const std::string & val_name )

inherited

set the value of name

Guarantee: strong

Failures: out of memory II

Definition at line 97 of file AsgComponentConfig.cxx.

   {
     m_name = val_name;
   }

◆ setProperty()

template<typename T >

StatusCode asg::AsgComponentConfig::setProperty	(	const std::string &	name,
		const T &	value
	)

inherited

set the given property

Guarantee: strong

Failures: could not convert to string
out of memory II

◆ setPropertyFromString()

void asg::AsgComponentConfig::setPropertyFromString	(	const std::string &	name,
		const std::string &	value
	)

inherited

set a given property from a string value

Guarantee: strong

Failures: out of memory II

Definition at line 132 of file AsgComponentConfig.cxx.

   {
     auto split = name.find ('.');
     if (split == std::string::npos)
     {
       m_propertyValues[name] = value;
     } else
     {
       auto subtool = accessSubtool (name, split);
       subtool.config->setPropertyFromString (subtool.name, value);
     }
   }

◆ setType()

void asg::AsgComponentConfig::setType ( const std::string & val_type )

inherited

set the value of type

Guarantee: strong

Failures: out of memory II

Definition at line 81 of file AsgComponentConfig.cxx.

   {
     m_type = val_type;
   }

◆ setTypeAndName()

void asg::AsgComponentConfig::setTypeAndName ( const std::string & val_typeAndName )

inherited

set type and name at the same time

Guarantee: basic

Failures: out of memory II

Definition at line 115 of file AsgComponentConfig.cxx.

   {
     const auto split = val_typeAndName.find ('/');
     if (split == std::string::npos)
     {
       setType (val_typeAndName);
       setName (val_typeAndName);
     } else
     {
       setType (val_typeAndName.substr (0,split));
       setName (val_typeAndName.substr (split+1));
     }
   }

◆ setUseXAODs()

void EL::AnaAlgorithmConfig::setUseXAODs ( bool val_useXAODs )

noexcept

set the value of useXAODs

Guarantee: no-fail

Definition at line 57 of file AnaAlgorithmConfig.cxx.

   {
     m_useXAODs = val_useXAODs;
   }

◆ type()

const std::string & asg::AsgComponentConfig::type ( ) const

noexceptinherited

the type of the component

Guarantee: no-fail

Definition at line 73 of file AsgComponentConfig.cxx.

   {
     return m_type;
   }

◆ typeAndName()

std::string asg::AsgComponentConfig::typeAndName ( ) const

inherited

get type and name at the same time

Guarantee: basic

Failures: out of memory II

Definition at line 105 of file AsgComponentConfig.cxx.

   {
     if (m_name == m_type)
       return m_name;
     return m_type + "/" + m_name;
   }

◆ useXAODs()

bool EL::AnaAlgorithmConfig::useXAODs ( ) const

noexcept

whether we use XAODs

Guarantee: no-fail

Definition at line 49 of file AnaAlgorithmConfig.cxx.

   {
     return m_useXAODs;
   }

Member Data Documentation

◆ m_isPublicTool

bool EL::AnaAlgorithmConfig::m_isPublicTool {false}

private

the value of isPublicTool

Definition at line 131 of file AnaAlgorithmConfig.h.

◆ m_name

std::string asg::AsgComponentConfig::m_name

privateinherited

the value of name

Definition at line 278 of file AsgComponentConfig.h.

◆ m_privateTools

std::map<std::string, details::AsgComponentPrivateToolConfig> asg::AsgComponentConfig::m_privateTools

privateinherited

the map of (private) tools to create

Definition at line 281 of file AsgComponentConfig.h.

◆ m_propertyValues

std::map<std::string,std::string> asg::AsgComponentConfig::m_propertyValues

privateinherited

the map of property values

Definition at line 288 of file AsgComponentConfig.h.

◆ m_toolArrays

std::map<std::string,std::vector<std::string> > asg::AsgComponentConfig::m_toolArrays

privateinherited

the map of (private) tool handle arrays to manage, and the tools they contain

Definition at line 285 of file AsgComponentConfig.h.

◆ m_type

std::string asg::AsgComponentConfig::m_type

privateinherited

the value of type

Definition at line 275 of file AsgComponentConfig.h.

◆ m_useXAODs

bool EL::AnaAlgorithmConfig::m_useXAODs = true

private

the value of useXAODs

Definition at line 127 of file AnaAlgorithmConfig.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

◆ AnaAlgorithmConfig() [1/3]

◆ AnaAlgorithmConfig() [2/3]

◆ AnaAlgorithmConfig() [3/3]

◆ ~AnaAlgorithmConfig()

Member Function Documentation

◆ accessSubtool()

◆ addPrivateTool()

◆ addPrivateToolInArray()

◆ checkTypeName()

◆ configureComponentExpert()

◆ createPrivateTool()

◆ createPrivateToolInArray()

◆ empty()

◆ isPublicTool()

◆ makeAlgorithm()

◆ name()

◆ setIsPublicTool()

◆ setName()

◆ setProperty()

◆ setPropertyFromString()

◆ setType()

◆ setTypeAndName()

◆ setUseXAODs()

◆ type()

◆ typeAndName()

◆ useXAODs()

Member Data Documentation

◆ m_isPublicTool

◆ m_name

◆ m_privateTools

◆ m_propertyValues

◆ m_toolArrays

◆ m_type

◆ m_useXAODs