a handle to a python tool for use via nanobind More...

#include <PythonToolHandle.h>

Inheritance diagram for columnar::PythonToolHandle:

Collaboration diagram for columnar::PythonToolHandle:

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

void	setTypeAndName (const std::string &typeAndName)
	set the type and name for the tool More...

template<typename T >
void	setProperty (const std::string &key, T &&value)
	set a property on the tool More...

const asg::AsgToolConfig &	getConfig () const
	get the AsgToolConfig More...

void	preinitialize ()
	preinitialize the tool More...

void	renameContainers (const std::vector< std::pair< std::string, std::string >> &renames)
	rename the columns the tool uses More...

void	initialize ()
	initialize the tool More...

void	applySystematicVariation (const std::string &sysName)
	set the tool to apply the given systematic variation More...

template<typename CT >
void	setColumn (const std::string &key, std::size_t size, CT *dataPtr)
	set a column pointer (raw pointer version) More...

void	setColumnVoid (const std::string &name, std::size_t size, const void *dataPtr, const std::type_info &type, bool isConst)
	set a column pointer More...

void	call ()
	call the tool and reset the columns More...

std::vector< ColumnInfo >	getColumnInfo () const
	get the expected column info More...

std::vector< std::string >	getColumnNames () const
	get the expected column names More...

std::vector< std::string >	getRecommendedSystematics () const
	get the recommended systematics More...

void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

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

Private Attributes
asg::AsgToolConfig	m_config

ToolHandle< asg::AsgTool >	m_toolHandle

std::shared_ptr< void >	m_cleanup

IColumnarTool *	m_tool = nullptr

CP::ISystematicsTool *	m_systTool = nullptr

std::shared_ptr< const ColumnVectorHeader >	m_columnHeader

std::shared_ptr< const ToolColumnVectorMap >	m_toolWrapper

std::unique_ptr< ColumnVectorData >	m_columns

std::string	m_nm
	Message source name. More...

boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...

std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...

std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...

std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

Detailed Description

a handle to a python tool for use via nanobind

This is meant to be used together with a nanobind python binding, to provide a higher level and stable interface to the tool wrappers. For other uses people should use the underlying interfaces directly or write a new higher level interface (depending on what's appropriate).

For now this is not thread-safe. The underlying code is thread-safe, as long as there is a separate ColumnarToolWrapperData object for each thread. Also, the way the tools handle setting systematics is currently not thread-safe.

Definition at line 38 of file PythonToolHandle.h.

Constructor & Destructor Documentation

◆ PythonToolHandle()

columnar::PythonToolHandle::PythonToolHandle ( )

inline

standard constructor

Public Members

Definition at line 46 of file PythonToolHandle.h.

46 : asg::AsgMessaging("PythonToolHandle") {}

Member Function Documentation

◆ applySystematicVariation()

void columnar::PythonToolHandle::applySystematicVariation ( const std::string & sysName )

inline

set the tool to apply the given systematic variation

Definition at line 126 of file PythonToolHandle.h.

     {
       // by convention setting a systematic on a non-systematics tool
       // will do nothing
       if (m_systTool == nullptr)
         return;
       if (!m_systTool->applySystematicVariation (CP::SystematicSet (sysName)).isSuccess())
         throw std::runtime_error ("failed to apply systematic variation");
     }

◆ call()

void columnar::PythonToolHandle::call ( )

inline

call the tool and reset the columns

Definition at line 153 of file PythonToolHandle.h.

     {
       if (!m_columns)
         throw std::runtime_error ("no columns set");
       m_columns->checkData ();
       m_columns->callNoCheck (*m_tool);
       m_columns = std::make_unique<ColumnVectorData> (m_columnHeader.get());
     }

◆ getColumnInfo()

std::vector<ColumnInfo> columnar::PythonToolHandle::getColumnInfo ( ) const

inline

get the expected column info

Definition at line 163 of file PythonToolHandle.h.

     {
       if (!m_toolWrapper)
         throw std::runtime_error ("tool not initialized");
       return m_tool->getColumnInfo ();
     }

◆ getColumnNames()

std::vector<std::string> columnar::PythonToolHandle::getColumnNames ( ) const

inline

get the expected column names

Definition at line 171 of file PythonToolHandle.h.

     {
       if (!m_toolWrapper)
         throw std::runtime_error ("tool not initialized");
       return m_toolWrapper->getColumnNames ();
     }

◆ getConfig()

const asg::AsgToolConfig& columnar::PythonToolHandle::getConfig ( ) const

inline

get the AsgToolConfig

Definition at line 63 of file PythonToolHandle.h.

     {
       return m_config;
     }

◆ getRecommendedSystematics()

std::vector<std::string> columnar::PythonToolHandle::getRecommendedSystematics ( ) const

inline

get the recommended systematics

Definition at line 179 of file PythonToolHandle.h.

     {
       if (!m_systTool)
         return {""};
       std::vector<std::string> result;
       for (auto& sys : CP::make_systematics_vector (m_systTool->recommendedSystematics()))
         result.push_back (sys.name());
       return result;
     }

◆ initialize()

void columnar::PythonToolHandle::initialize ( )

inline

initialize the tool

Definition at line 114 of file PythonToolHandle.h.

     {
       if (m_tool == nullptr)
         preinitialize ();
  
       auto columnHeader = std::make_shared<ColumnVectorHeader> ();
       m_columnHeader = columnHeader;
       m_toolWrapper = std::make_shared<ToolColumnVectorMap> (*columnHeader, *m_tool);
       m_columns = std::make_unique<ColumnVectorData> (m_columnHeader.get());
     }

◆ 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();
   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
    }

◆ preinitialize()

void columnar::PythonToolHandle::preinitialize ( )

inline

preinitialize the tool

Definition at line 69 of file PythonToolHandle.h.

     {
       ANA_MSG_DEBUG("preinitializing with " << m_toolHandle << " and cleanup " << m_cleanup);
       if (!m_config.makeTool (m_toolHandle, m_cleanup).isSuccess())
         throw std::runtime_error ("failed to create tool");
  
       ANA_MSG_DEBUG("m_config created tool" << m_toolHandle);
  
       m_tool = dynamic_cast<IColumnarTool*> (&*m_toolHandle);
  
       ANA_MSG_DEBUG("attempting to dynamically cast to IColumnarTool* gives " << m_tool);
       if (m_tool == nullptr)
         throw std::runtime_error ("The tool does not implement IColumnarTool. First, check to make sure you're in the ColumnarAnalysis release. Then, check to see if the tool inherits from ColumnarTool.");
       m_systTool = dynamic_cast<CP::ISystematicsTool*> (m_tool);
     }

◆ renameContainers()

void columnar::PythonToolHandle::renameContainers ( const std::vector< std::pair< std::string, std::string >> & renames )

inline

rename the columns the tool uses

Definition at line 86 of file PythonToolHandle.h.

     {
       if (m_tool == nullptr)
         preinitialize ();
       {
         auto columnInfo = m_tool->getColumnInfo ();
         for (auto& [from, to] : renames)
         {
           for (auto& column : columnInfo)
           {
             if (column.name.starts_with (from) && (column.name.size() == from.size() || column.name[from.size()] == '.'))
             {
               std::string newName = to + column.name.substr (from.size());
               m_tool->renameColumn (column.name, newName);
             }
           }
         }
       }
       if (m_toolWrapper)
       {
         auto columnHeader = std::make_shared<ColumnVectorHeader> ();
         m_columnHeader = columnHeader;
         m_toolWrapper = std::make_shared<ToolColumnVectorMap> (*columnHeader, *m_tool);
         m_columns = std::make_unique<ColumnVectorData> (m_columnHeader.get());
       }
     }

◆ setColumn()

template<typename CT >

void columnar::PythonToolHandle::setColumn	(	const std::string &	key,
		std::size_t	size,
		CT *	dataPtr
	)

inline

set a column pointer (raw pointer version)

Definition at line 138 of file PythonToolHandle.h.

     {
       if (!m_columns)
         throw std::runtime_error ("tool not initialized");
       m_columns->setColumn (m_toolWrapper->getColumnIndex (key), size, dataPtr);
     }

◆ setColumnVoid()

void columnar::PythonToolHandle::setColumnVoid	(	const std::string &	name,
		std::size_t	size,
		const void *	dataPtr,
		const std::type_info &	type,
		bool	isConst
	)

inline

set a column pointer

Definition at line 146 of file PythonToolHandle.h.

                                                                                                                             {
       if (!m_columns)
         throw std::runtime_error ("tool not initialized");
       m_columns->setColumnVoid (m_toolWrapper->getColumnIndex (name), size, dataPtr, type, isConst);
     }

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

◆ setProperty()

template<typename T >

void columnar::PythonToolHandle::setProperty	(	const std::string &	key,
		T &&	value
	)

inline

set a property on the tool

Definition at line 56 of file PythonToolHandle.h.

     {
       if (m_config.setProperty (key, std::forward<T> (value)).isFailure())
         throw std::runtime_error ("failed to set property: " + key);
     }

◆ setTypeAndName()

void columnar::PythonToolHandle::setTypeAndName ( const std::string & typeAndName )

inline

set the type and name for the tool

Definition at line 49 of file PythonToolHandle.h.

     {
       m_config.setTypeAndName (typeAndName);
     }

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_cleanup

std::shared_ptr<void> columnar::PythonToolHandle::m_cleanup

private

Definition at line 198 of file PythonToolHandle.h.

◆ m_columnHeader

std::shared_ptr<const ColumnVectorHeader> columnar::PythonToolHandle::m_columnHeader

private

Definition at line 203 of file PythonToolHandle.h.

◆ m_columns

std::unique_ptr<ColumnVectorData> columnar::PythonToolHandle::m_columns

private

Definition at line 205 of file PythonToolHandle.h.

◆ m_config

asg::AsgToolConfig columnar::PythonToolHandle::m_config

private

Private Members

Definition at line 196 of file PythonToolHandle.h.

◆ m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_lvl

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

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ 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_systTool

CP::ISystematicsTool* columnar::PythonToolHandle::m_systTool = nullptr

private

Definition at line 201 of file PythonToolHandle.h.

◆ m_tool

IColumnarTool* columnar::PythonToolHandle::m_tool = nullptr

private

Definition at line 200 of file PythonToolHandle.h.

◆ m_toolHandle

ToolHandle<asg::AsgTool> columnar::PythonToolHandle::m_toolHandle

private

Definition at line 197 of file PythonToolHandle.h.

◆ m_toolWrapper

std::shared_ptr<const ToolColumnVectorMap> columnar::PythonToolHandle::m_toolWrapper

private

Definition at line 204 of file PythonToolHandle.h.

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

PythonToolHandle.h

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PythonToolHandle()

Public Members

Member Function Documentation

◆ applySystematicVariation()

◆ call()

◆ getColumnInfo()

◆ getColumnNames()

◆ getConfig()

◆ getRecommendedSystematics()

◆ initialize()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ preinitialize()

◆ renameContainers()

◆ setColumn()

◆ setColumnVoid()

◆ setLevel()

◆ setProperty()

◆ setTypeAndName()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_cleanup

◆ m_columnHeader

◆ m_columns

◆ m_config

Private Members

◆ m_imsg

◆ m_lvl

◆ m_msg_tls

◆ m_nm

◆ m_systTool

◆ m_tool

◆ m_toolHandle

◆ m_toolWrapper