The DataOnDemandSvc listens to incidents typically triggered by the data service of the configurable name "IncidentName". More...

#include </builds/gaudi/Gaudi/GaudiCoreSvc/src/IncidentSvc/DataOnDemandSvc.h>

Inheritance diagram for DataOnDemandSvc:

[legend]

Collaboration diagram for DataOnDemandSvc:

[legend]

Classes
struct	Leaf

struct	Node
	Helper class of the DataOnDemandSvc. More...

struct	Protection
	Helper class of the DataOnDemandSvc. More...

Public Types
typedef std::vector< std::string >	Setup

typedef TClass *	ClassH

typedef GaudiUtils::HashMap< Gaudi::StringKey, Node >	NodeMap

typedef GaudiUtils::HashMap< Gaudi::StringKey, Leaf >	AlgMap

Public Types inherited from extends< Service, IIncidentListener >
using	base_class
	Typedef to this class.

using	extend_interfaces_base
	Typedef to the base of this class.

Public Types inherited from Service
using	Factory = Gaudi::PluginService::Factory<IService( const std::string&, ISvcLocator )>

Public Types inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
using	PropertyHolderImpl
	Typedef used to refer to this class from derived classes, as in.

Public Types inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
using	base_class

Public Types inherited from extend_interfaces< Interfaces... >
using	ext_iids
	take union of the ext_iids of all Interfaces...

Public Member Functions
StatusCode	initialize () override
	Inherited Service overrides: Service initialization.

StatusCode	finalize () override
	Inherited Service overrides: Service finalization.

StatusCode	reinitialize () override
	Inherited Service overrides: Service reinitialization.

void	handle (const Incident &incident) override
	IIncidentListener interfaces overrides: incident handling.

Public Member Functions inherited from extends< Service, IIncidentListener >
void const *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast.

StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface.

std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames.

Public Member Functions inherited from Service
const std::string &	name () const override
	Retrieve name of the service.

StatusCode	configure () override

StatusCode	initialize () override

StatusCode	start () override

StatusCode	stop () override

StatusCode	finalize () override

StatusCode	terminate () override

Gaudi::StateMachine::State	FSMState () const override

Gaudi::StateMachine::State	targetFSMState () const override

StatusCode	reinitialize () override

StatusCode	restart () override

StatusCode	sysInitialize () override
	Initialize Service.

StatusCode	sysStart () override
	Initialize Service.

StatusCode	sysStop () override
	Initialize Service.

StatusCode	sysFinalize () override
	Finalize Service.

StatusCode	sysReinitialize () override
	Re-initialize the Service.

StatusCode	sysRestart () override
	Re-initialize the Service.

	Service (std::string name, ISvcLocator *svcloc)
	Standard Constructor.

SmartIF< ISvcLocator > &	serviceLocator () const override
	Retrieve pointer to service locator.

template<typename IFace = IService>
SmartIF< IFace >	service (const std::string &name, bool createIf=true) const

template<class T>
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandle< T > &hndl, const std::string &doc="none")

template<class T>
StatusCode	declareTool (ToolHandle< T > &handle, bool createIf=true)

template<class T>
StatusCode	declareTool (ToolHandle< T > &handle, const std::string &toolTypeAndName, bool createIf=true)
	Declare used tool.

template<class T>
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandleArray< T > &hndlArr, const std::string &doc="none")

template<class T>
void	addToolsArray (ToolHandleArray< T > &hndlArr)

const std::vector< IAlgTool * > &	tools () const

SmartIF< IAuditorSvc > &	auditorSvc () const
	The standard auditor service.May not be invoked before sysInitialize() has been invoked.

Public Member Functions inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property.

StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals.

StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string.

StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value

	PropertyHolder ()=default

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Details::PropertyBase &prop)
	Declare a property.

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, TYPE &value, const std::string &doc="none")
	Helper to wrap a regular data member and use it as a regular property.

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, Gaudi::Property< TYPE, VERIFIER, HANDLERS > &prop, const std::string &doc="none")
	Declare a PropertyBase instance setting name and documentation.

Gaudi::Details::PropertyBase *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="")
	Declare a remote property.

StatusCode	setProperty (const std::string &name, const Gaudi::Details::PropertyBase &p) override
	set the property from another property with a different name

StatusCode	setProperty (const std::string &s) override
	set the property from the formatted string

StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property.

StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals.

StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string.

StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value

StatusCode	setPropertyRepr (const std::string &n, const std::string &r) override
	set the property from name and value string representation

StatusCode	getProperty (Gaudi::Details::PropertyBase *p) const override
	get the property

const Gaudi::Details::PropertyBase &	getProperty (std::string_view name) const override
	get the property by name

StatusCode	getProperty (std::string_view n, std::string &v) const override
	convert the property to the string

const std::vector< Gaudi::Details::PropertyBase * > &	getProperties () const override
	get all properties

bool	hasProperty (std::string_view name) const override
	Return true if we have a property with the given name.

Gaudi::Details::PropertyBase *	property (std::string_view name) const
	\fixme property and bindPropertiesTo should be protected

void	bindPropertiesTo (Gaudi::Interfaces::IOptionsSvc &optsSvc)

	PropertyHolder (const PropertyHolder &)=delete

PropertyHolder &	operator= (const PropertyHolder &)=delete

Public Member Functions inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
MSG::Level	msgLevel () const
	get the cached level (originally extracted from the embedded MsgStream)

bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream

Public Member Functions inherited from CommonMessagingBase
virtual	~CommonMessagingBase ()=default
	Virtual destructor.

const SmartIF< IMessageSvc > &	msgSvc () const
	The standard message service.

MsgStream &	msgStream () const
	Return an uninitialized MsgStream.

MsgStream &	msgStream (const MSG::Level level) const
	Predefined configurable message stream for the efficient printouts.

MsgStream &	always () const
	shortcut for the method msgStream(MSG::ALWAYS)

MsgStream &	fatal () const
	shortcut for the method msgStream(MSG::FATAL)

MsgStream &	err () const
	shortcut for the method msgStream(MSG::ERROR)

MsgStream &	error () const
	shortcut for the method msgStream(MSG::ERROR)

MsgStream &	warning () const
	shortcut for the method msgStream(MSG::WARNING)

MsgStream &	info () const
	shortcut for the method msgStream(MSG::INFO)

MsgStream &	debug () const
	shortcut for the method msgStream(MSG::DEBUG)

MsgStream &	verbose () const
	shortcut for the method msgStream(MSG::VERBOSE)

MsgStream &	msg () const
	shortcut for the method msgStream(MSG::INFO)

Protected Member Functions
StatusCode	configureHandler (Leaf &leaf)
	Configure handler for leaf.

StatusCode	execHandler (const std::string &tag, Leaf &leaf)
	Execute leaf handler (algorithm)

StatusCode	execHandler (const std::string &tag, Node &node)
	Execute node handler (simple object creation using seal reflection)

StatusCode	setupNodeHandlers ()
	Initialize node handlers.

StatusCode	setupAlgHandlers ()
	Initialize leaf handlers.

StatusCode	setup ()
	Setup routine (called by (re-) initialize.

void	i_setNodeHandler (const std::string &name, const std::string &type)
	Internal method to initialize a node handler.

StatusCode	i_setAlgHandler (const std::string &name, const Gaudi::Utils::TypeNameString &alg)
	Internal method to initialize an algorithm handler.

StatusCode	update ()
	update the handlers

void	dump (const MSG::Level level, const bool mode=true) const
	dump the content of DataOnDemand service

Protected Member Functions inherited from Service
std::vector< IAlgTool * > &	tools ()

	~Service () override

int	outputLevel () const
	get the `Service's` output level

Protected Member Functions inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
MSG::Level	setUpMessaging () const
	Set up local caches.

MSG::Level	resetMessaging ()
	Reinitialize internal states.

void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream.

Private Types
typedef std::map< std::string, std::string >	Map

Private Member Functions
void	force_update (Gaudi::Details::PropertyBase &p)

void	deprecated_property (Gaudi::Details::PropertyBase &p)

Private Attributes
SmartIF< IIncidentSvc >	m_incSvc = nullptr
	Incident service.

SmartIF< IAlgManager >	m_algMgr = nullptr
	Algorithm manager.

SmartIF< IDataProviderSvc >	m_dataSvc = nullptr
	Data provider reference.

SmartIF< IToolSvc >	m_toolSvc
	Data provider reference.

AlgMap	m_algs
	Map of algorithms to handle incidents.

NodeMap	m_nodes
	Map of "empty" objects to be placed as intermediate nodes.

bool	m_updateRequired = true

ChronoEntity	m_total

unsigned long long	m_statAlg = 0

unsigned long long	m_statNode = 0

unsigned long long	m_stat = 0

ChronoEntity	m_timer_nodes

ChronoEntity	m_timer_algs

ChronoEntity	m_timer_all

bool	m_locked_nodes = false

bool	m_locked_algs = false

bool	m_locked_all = false

std::vector< IDODNodeMapper * >	m_nodeMappers

std::vector< IDODAlgMapper * >	m_algMappers

Gaudi::Property< std::string >	m_trapType { this, "IncidentName", "DataFault", "the type of handled Incident" }

Gaudi::Property< std::string >	m_dataSvcName { this, "DataSvc", "EventDataSvc", "DataSvc name" }

Gaudi::Property< bool >	m_partialPath { this, "UsePreceedingPath", true, "allow creation of partial leaves" }

Gaudi::Property< bool >	m_dump

Gaudi::Property< bool >	m_init { this, "PreInitialize", false, "(pre)initialize all algorithms" }

Gaudi::Property< bool >	m_allowInitFailure

Gaudi::Property< Setup >	m_algMapping

Gaudi::Property< Setup >	m_nodeMapping

Gaudi::Property< Map >	m_algMap { this, "AlgMap", {}, &DataOnDemandSvc::force_update, "mapping {'data': 'algorithm'}" }

Gaudi::Property< Map >	m_nodeMap { this, "NodeMap", {}, &DataOnDemandSvc::force_update, "mapping {'data': 'type'}" }

Gaudi::Property< std::string >	m_prefix { this, "Prefix", "/Event/" }

Gaudi::Property< std::vector< std::string > >	m_nodeMapTools

Gaudi::Property< std::vector< std::string > >	m_algMapTools

Additional Inherited Members
Protected Attributes inherited from Service
Gaudi::StateMachine::State	m_state = Gaudi::StateMachine::OFFLINE
	Service state.

Gaudi::StateMachine::State	m_targetState = Gaudi::StateMachine::OFFLINE
	Service state.

Gaudi::Property< int >	m_outputLevel { this, "OutputLevel", MSG::NIL, "output level" }
	flag indicating whether ToolHandle tools have been added to m_tools

Gaudi::Property< bool >	m_auditorInitialize { this, "AuditInitialize", false, "trigger auditor on initialize()" }

Gaudi::Property< bool >	m_auditorStart { this, "AuditStart", false, "trigger auditor on start()" }

Gaudi::Property< bool >	m_auditorStop { this, "AuditStop", false, "trigger auditor on stop()" }

Gaudi::Property< bool >	m_auditorFinalize { this, "AuditFinalize", false, "trigger auditor on finalize()" }

Gaudi::Property< bool >	m_auditorReinitialize { this, "AuditReinitialize", false, "trigger auditor on reinitialize()" }

Gaudi::Property< bool >	m_auditorRestart { this, "AuditRestart", false, "trigger auditor on restart()" }

Gaudi::Property< bool >	m_autoRetrieveTools

Gaudi::Property< bool >	m_checkToolDeps

SmartIF< IAuditorSvc >	m_pAuditorSvc
	Auditor Service.

Detailed Description

The DataOnDemandSvc listens to incidents typically triggered by the data service of the configurable name "IncidentName".

In the job options handlers can be declared, which allow to configure this service. Such handlers are either:

Node handlers, if objects other than the default object type have to be instantiated. DataOnDemandSvc.Nodes = { "DATA='/Event/Rec' TYPE='DataObject'", "DATA='/Event/Rec/Muon' TYPE='DataObject'" };
Leaf handlers (Algorithms), which get instantiated and executed on demand. DataOnDemandSvc.Algorithms = { "DATA='/Event/Rec/Muon/Digits' TYPE='MuonDigitAlg/MyMuonDigits'" }; If the algorithm name is omitted the class name will be the instance name.

The handlers only get called if the exact path matches. In the event already the partial path to any handler is missing a leaf handler may be triggered, which includes the partial paths ( DataOnDemandSvc.UsePreceedingPath = true )

2006-10-15: New options (using map-like semantics:)

 DataOnDemandSvc.AlgMap  +=
{ "Phys/StdLoosePions/Particles" : "PreLoadParticles/StdLoosePions" ,
  "Phys/StdLoosePions/Vertioces" : "PreLoadParticles/StdLoosePions" } ;
 
 DataOnDemandSvc.NodeMap +=
{ "Phys" : "DataObject" ,
  "MC"   : "DataObject" } ;

New treatment of preceding paths. for each registered leaf or node the all parent nodes are added into the node-map with default directory type 'DataObject'

The major properties are equipped with handlers (more or less mandatory for interactive work in python)

From now the default prefix ( "/Event/" ) could be omitted from any data-item. It will be added automatically.

Author: M.Frank

Version: 1.0

Definition at line 87 of file DataOnDemandSvc.h.

Member Typedef Documentation

◆ AlgMap

typedef GaudiUtils::HashMap<Gaudi::StringKey, Leaf> DataOnDemandSvc::AlgMap

Definition at line 135 of file DataOnDemandSvc.h.

◆ ClassH

typedef TClass* DataOnDemandSvc::ClassH

Definition at line 90 of file DataOnDemandSvc.h.

◆ Map

typedef std::map<std::string, std::string> DataOnDemandSvc::Map

private

Definition at line 245 of file DataOnDemandSvc.h.

◆ NodeMap

typedef GaudiUtils::HashMap<Gaudi::StringKey, Node> DataOnDemandSvc::NodeMap

Definition at line 134 of file DataOnDemandSvc.h.

◆ Setup

typedef std::vector<std::string> DataOnDemandSvc::Setup

Definition at line 89 of file DataOnDemandSvc.h.

Member Function Documentation

◆ configureHandler()

StatusCode DataOnDemandSvc::configureHandler ( Leaf & leaf )

protected

Configure handler for leaf.

Parameters

leaf	[IN] Reference to leaf handler

Returns: StatusCode indicating success or failure

Definition at line 347 of file DataOnDemandSvc.cpp.

                                                      {
  if ( l.algorithm ) { return StatusCode::SUCCESS; }
  if ( !m_algMgr ) { return StatusCode::FAILURE; }
  l.algorithm = m_algMgr->algorithm( l.name, false );
  if ( l.algorithm ) { return StatusCode::SUCCESS; }
  // create it!
  StatusCode sc = m_algMgr->createAlgorithm( l.type, l.name, l.algorithm, true );
  if ( sc.isFailure() ) {
    error() << "Failed to create algorithm " << l.type << "('" << l.name << "')" << endmsg;
    l.algorithm = nullptr;
    return sc;
  }
  if ( l.algorithm->isInitialized() ) { return StatusCode::SUCCESS; }
  // initialize it!
  sc = l.algorithm->sysInitialize();
  if ( sc.isFailure() ) {
    error() << "Failed to initialize algorithm " << l.type << "('" << l.name << "')" << endmsg;
    l.algorithm = nullptr;
    return sc;
  }
  if ( Gaudi::StateMachine::RUNNING == l.algorithm->FSMState() ) { return StatusCode::SUCCESS; }
  // run it!
  sc = l.algorithm->sysStart();
  if ( sc.isFailure() ) {
    error() << "Failed to 'run'      algorithm " << l.type << "('" << l.name << "')" << endmsg;
    l.algorithm = nullptr;
    return sc;
  }
  return StatusCode::SUCCESS;
}

◆ deprecated_property()

void DataOnDemandSvc::deprecated_property ( Gaudi::Details::PropertyBase & p )

inlineprivate

Definition at line 190 of file DataOnDemandSvc.h.

                                                          {
    warning() << p.name() << " " << p.documentation() << endmsg;
    force_update( p );
  };

◆ dump()

void DataOnDemandSvc::dump	(	const MSG::Level	level,
		const bool	mode = true ) const

protected

dump the content of DataOnDemand service

Parameters

level	the printout level
mode	the printout mode

Definition at line 554 of file DataOnDemandSvc.cpp.

                                                                        {
  if ( m_algs.empty() && m_nodes.empty() ) { return; }
 
  typedef std::pair<std::string, std::string> Pair;
  std::map<std::string, Pair>                 _m;
  for ( auto& alg : m_algs ) {
    auto check = _m.find( alg.first );
    if ( _m.end() != check ) {
      warning() << " The data item is activated for '" << check->first << "' as '" << check->second.first << "'"
                << endmsg;
    }
    const Leaf& l   = alg.second;
    std::string nam = ( l.name == l.type ? l.type : ( l.type + "/" + l.name ) );
 
    if ( !mode && 0 == l.num ) { continue; }
 
    std::string val;
    if ( mode ) {
      val = ( !l.algorithm ) ? "F" : "T";
    } else {
      val = std::to_string( l.num );
    }
 
    _m[no_prefix( alg.first, m_prefix )] = { nam, val };
  }
  // nodes:
  for ( const auto& node : m_nodes ) {
    auto check = _m.find( node.first );
    if ( _m.end() != check ) {
      warning() << " The data item is already activated for '" << check->first << "' as '" << check->second.first << "'"
                << endmsg;
    }
    const Node& n   = node.second;
    std::string nam = "'" + n.name + "'";
 
    std::string val;
 
    if ( !mode && 0 == n.num ) { continue; }
 
    if ( mode ) {
      val = ( 0 == n.clazz ) ? "F" : "T";
    } else {
      val = std::to_string( n.num );
    }
 
    _m[no_prefix( node.first, m_prefix )] = { nam, val };
  }
 
  if ( _m.empty() ) { return; }
 
  // set width of the columns
  size_t n1 = 10; // minimum width
  size_t n2 = 10; // minimum width
  size_t n3 = 0;
  for ( const auto& i : _m ) {
    n1 = std::max( n1, i.first.size() );
    n2 = std::max( n2, i.second.first.size() );
    n3 = std::max( n3, i.second.second.size() );
  }
  n1 = std::min( n1, size_t{ 60 } ); // maximum width
  n2 = std::min( n2, size_t{ 60 } ); // maximum width
 
  auto& msg = msgStream( level );
 
  if ( mode ) {
    msg << "Data-On-Demand Actions enabled for:";
  } else {
    msg << "Data-On-Demand Actions has been used for:";
  }
 
  const auto header = fmt::format( " | {3:<{0}.{0}s} | {4:<{1}.{1}s} | {5:>{2}.{2}s} |", n1, n2, n3, "Address",
                                   "Creator", ( mode ? "S" : "#" ) );
  const auto line   = fmt::format( " {0:-^{1}}", "", header.size() - 1 );
  msg << '\n' << line << '\n' << header << '\n' << line;
 
  // make the actual printout:
  for ( const auto& item : _m ) {
    msg << fmt::format( "\n | {3:<{0}.{0}s} | {4:<{1}.{1}s} | {5:>{2}.{2}s} |", n1, n2, n3, item.first,
                        item.second.first, item.second.second );
  }
 
  msg << '\n' << line << endmsg;
}

◆ execHandler() [1/2]

StatusCode DataOnDemandSvc::execHandler	(	const std::string &	tag,
		Leaf &	leaf )

protected

Execute leaf handler (algorithm)

Parameters

tag	[IN] Path to requested leaf
leaf	[IN] Reference to leaf handler

Returns: StatusCode indicating success or failure

Definition at line 524 of file DataOnDemandSvc.cpp.

                                                                       {
  Gaudi::Utils::LockedChrono timer( m_timer_algs, m_locked_algs );
 
  if ( l.executing ) { return StatusCode::FAILURE; }
 
  if ( !l.algorithm ) {
    StatusCode sc = configureHandler( l );
    if ( sc.isFailure() ) {
      error() << "Failed to configure handler for: " << l.name << "[" << l.type << "] " << tag << endmsg;
      return sc;
    }
  }
 
  Chrono atimer( m_total );
 
  Protection p( l.executing );
  // FIXME: this will cause problems for Hive, as we need to set
  // the EventContext of the called Algorithm.
  // if (!l.algorithm->getContext()) {
  //   l.algorithm->setContext( &Gaudi::Hive::currentContext() );
  // }
  StatusCode sc = l.algorithm->sysExecute( Gaudi::Hive::currentContext() );
  if ( sc.isFailure() ) {
    error() << "Failed to execute the algorithm:" << l.algorithm->name() << " for location:" << tag << endmsg;
    return sc;
  }
  ++l.num;
 
  return StatusCode::SUCCESS;
}

◆ execHandler() [2/2]

StatusCode DataOnDemandSvc::execHandler	(	const std::string &	tag,
		Node &	node )

protected

Execute node handler (simple object creation using seal reflection)

Parameters

tag	[IN] Path to requested leaf
node	[IN] Reference to node handler

Returns: StatusCode indicating success or failure

Definition at line 487 of file DataOnDemandSvc.cpp.

                                                                       {
 
  Gaudi::Utils::LockedChrono timer( m_timer_nodes, m_locked_nodes );
 
  if ( n.executing ) { return StatusCode::FAILURE; }
 
  Protection p( n.executing );
 
  std::unique_ptr<DataObject> object;
 
  if ( n.dataObject ) {
    object.reset( new DataObject() );
  } else {
    // try to recover the handler
    if ( !n.clazz ) { n.clazz = TClass::GetClass( n.name.c_str() ); }
    if ( !n.clazz ) {
      error() << "Failed to get dictionary for class '" << n.name << "' for location:" << tag << endmsg;
      return StatusCode::FAILURE;
    }
 
    object.reset( reinterpret_cast<DataObject*>( n.clazz->New() ) );
 
    if ( !object ) {
      error() << "Failed to create an object of type:" << n.clazz->GetName() << " for location:" << tag << endmsg;
      return StatusCode::FAILURE;
    }
  }
  //
  StatusCode sc = m_dataSvc->registerObject( tag, object.release() );
  if ( sc.isFailure() ) {
    error() << "Failed to register an object of type:" << n.name << " at location:" << tag << endmsg;
    return sc;
  }
  ++n.num;
  //
  return StatusCode::SUCCESS;
}

◆ finalize()

StatusCode DataOnDemandSvc::finalize ( )

override

Inherited Service overrides: Service finalization.

Definition at line 179 of file DataOnDemandSvc.cpp.

                                     {
  info() << "Handled \"" << m_trapType.value() << "\" incidents: " << m_statAlg << "/" << m_statNode << "/" << m_stat
         << "(Alg/Node/Total)." << endmsg;
  if ( m_dump || msgLevel( MSG::DEBUG ) ) {
    info() << m_total.outputUserTime( "Algorithm timing: Mean(+-rms)/Min/Max:%3%(+-%4%)/%6%/%7%[ms] ",
                                      System::milliSec )
           << m_total.outputUserTime( "Total:%2%[s]", System::Sec ) << endmsg;
    info() << m_timer_nodes.outputUserTime( "Nodes     timing: Mean(+-rms)/Min/Max:%3%(+-%4%)/%6%/%7%[ms] ",
                                            System::milliSec )
           << m_timer_nodes.outputUserTime( "Total:%2%[s]", System::Sec ) << endmsg;
    info() << m_timer_algs.outputUserTime( "Algs      timing: Mean(+-rms)/Min/Max:%3%(+-%4%)/%6%/%7%[ms] ",
                                           System::milliSec )
           << m_timer_algs.outputUserTime( "Total:%2%[s]", System::Sec ) << endmsg;
    info() << m_timer_all.outputUserTime( "All       timing: Mean(+-rms)/Min/Max:%3%(+-%4%)/%6%/%7%[ms] ",
                                          System::milliSec )
           << m_timer_all.outputUserTime( "Total:%2%[s]", System::Sec ) << endmsg;
  }
  // dump it!
  if ( m_dump ) {
    dump( MSG::INFO, false );
  } else if ( msgLevel( MSG::DEBUG ) ) {
    dump( MSG::DEBUG, false );
  }
 
  if ( m_incSvc ) {
    m_incSvc->removeListener( this, m_trapType );
    m_incSvc.reset();
  }
  m_algMgr.reset();
  m_dataSvc.reset();
  if ( m_toolSvc ) { // we may not have retrieved the ToolSvc
    // Do not call releaseTool if the ToolSvc was already finalized.
    if ( SmartIF<IStateful>( m_toolSvc )->FSMState() > Gaudi::StateMachine::CONFIGURED ) {
      for ( const auto& i : m_nodeMappers ) m_toolSvc->releaseTool( i ).ignore();
      for ( const auto& i : m_algMappers ) m_toolSvc->releaseTool( i ).ignore();
    } else {
      warning() << "ToolSvc already finalized: cannot release tools. Check options." << endmsg;
    }
    m_nodeMappers.clear();
    m_algMappers.clear();
    m_toolSvc.reset();
  }
  return Service::finalize();
}

◆ force_update()

void DataOnDemandSvc::force_update ( Gaudi::Details::PropertyBase & p )

inlineprivate

Definition at line 186 of file DataOnDemandSvc.h.

                                                   {
    verbose() << "updated property " << p.name() << ", forcing update" << endmsg;
    m_updateRequired = true;
  };

◆ handle()

void DataOnDemandSvc::handle ( const Incident & incident )

override

IIncidentListener interfaces overrides: incident handling.

Definition at line 426 of file DataOnDemandSvc.cpp.

                                                       {
 
  Gaudi::Utils::LockedChrono timer( m_timer_all, m_locked_all );
 
  ++m_stat;
  // proper incident type?
  if ( incident.type() != m_trapType ) { return; }
  const DataIncident* inc = dynamic_cast<const DataIncident*>( &incident );
  if ( !inc ) { return; }
  // update if needed!
  if ( m_updateRequired ) {
    if ( !update() ) throw GaudiException( "Failed to update", name(), StatusCode::FAILURE );
  }
 
  if ( msgLevel( MSG::VERBOSE ) ) {
    verbose() << "Incident: [" << incident.type() << "] "
              << " = " << incident.source() << " Location:" << inc->tag() << endmsg;
  }
 
  Gaudi::StringKey tag( inc->tag() );
 
  auto icl = m_nodes.find( tag );
  if ( icl != m_nodes.end() ) {
    StatusCode sc = execHandler( tag, icl->second );
    if ( sc.isSuccess() ) { ++m_statNode; }
    return;
  }
 
  auto ialg = m_algs.find( tag );
  if ( ialg != m_algs.end() ) {
    StatusCode sc = execHandler( tag, ialg->second );
    if ( sc.isSuccess() ) { ++m_statAlg; }
    return;
  }
 
  // Fall back on the tools
  if ( m_toolSvc ) {
    if ( msgLevel( MSG::VERBOSE ) ) verbose() << "Try to find mapping with mapping tools" << endmsg;
    Finder finder( no_prefix( inc->tag(), m_prefix ), m_nodeMappers, m_algMappers );
    //  - try the node mappers
    std::string node = finder.node();
    if ( isGood( node ) ) {
      // if one is found update the internal node mapping and try again.
      if ( msgLevel( MSG::VERBOSE ) ) verbose() << "Found Node handler: " << node << endmsg;
      i_setNodeHandler( inc->tag(), node );
      handle( incident );
      --m_stat; // avoid double counting because of recursion
      return;
    }
    //  - try alg mappings
    Gaudi::Utils::TypeNameString alg = finder.alg();
    if ( isGood( alg ) ) {
      // we got an algorithm, update alg map and try to handle again
      if ( msgLevel( MSG::VERBOSE ) ) verbose() << "Found Algorithm handler: " << alg << endmsg;
      i_setAlgHandler( inc->tag(), alg ).ignore();
      handle( incident );
      --m_stat; // avoid double counting because of recursion
      return;
    }
  }
}

◆ i_setAlgHandler()

StatusCode DataOnDemandSvc::i_setAlgHandler	(	const std::string &	name,
		const Gaudi::Utils::TypeNameString &	alg )

protected

Internal method to initialize an algorithm handler.

Definition at line 99 of file DataOnDemandSvc.cpp.

                                                                                                        {
  Leaf leaf( alg.type(), alg.name() );
  if ( m_init ) {
    StatusCode sc = configureHandler( leaf );
    if ( sc.isFailure() ) {
      if ( m_allowInitFailure ) {
        // re-store the content of the leaf object to try again to initialize
        // the algorithm later (on demand)
        leaf = Leaf( alg.type(), alg.name() );
      } else
        return sc;
    }
  }
  m_algs[name] = leaf;
  return StatusCode::SUCCESS;
}

◆ i_setNodeHandler()

void DataOnDemandSvc::i_setNodeHandler	(	const std::string &	name,
		const std::string &	type )

protected

Internal method to initialize a node handler.

Definition at line 93 of file DataOnDemandSvc.cpp.

                                                                                     {
  ClassH cl = TClass::GetClass( type.c_str() );
  if ( !cl ) { warning() << "Failed to access dictionary class for " << name << " of type:" << type << endmsg; }
  m_nodes[name] = Node( cl, false, type );
}

◆ initialize()

StatusCode DataOnDemandSvc::initialize ( )

override

Inherited Service overrides: Service initialization.

Definition at line 162 of file DataOnDemandSvc.cpp.

                                       {
  // initialize the Service Base class
  StatusCode sc = Service::initialize();
  if ( sc.isFailure() ) { return sc; }
  sc = setup();
  if ( sc.isFailure() ) { return sc; }
  //
  if ( m_dump ) {
    dump( MSG::INFO );
  } else if ( msgLevel( MSG::DEBUG ) ) {
    dump( MSG::DEBUG );
  }
 
  if ( m_init ) { return update(); }
 
  return StatusCode::SUCCESS;
}

◆ reinitialize()

StatusCode DataOnDemandSvc::reinitialize ( )

override

Inherited Service overrides: Service reinitialization.

Definition at line 223 of file DataOnDemandSvc.cpp.

                                         {
  // reinitialize the Service Base class
  if ( m_incSvc ) {
    m_incSvc->removeListener( this, m_trapType );
    m_incSvc.reset();
  }
  m_algMgr.reset();
  m_dataSvc.reset();
  for ( const auto& i : m_nodeMappers ) m_toolSvc->releaseTool( i ).ignore();
  m_nodeMappers.clear();
  for ( const auto& i : m_algMappers ) m_toolSvc->releaseTool( i ).ignore();
  m_algMappers.clear();
  m_toolSvc.reset();
 
  StatusCode sc = Service::reinitialize();
  if ( sc.isFailure() ) { return sc; }
 
  sc = setup();
  if ( sc.isFailure() ) { return sc; }
 
  if ( m_dump ) {
    dump( MSG::INFO );
  } else if ( msgLevel( MSG::DEBUG ) ) {
    dump( MSG::DEBUG );
  }
 
  return StatusCode::SUCCESS;
}

◆ setup()

StatusCode DataOnDemandSvc::setup ( )

protected

Setup routine (called by (re-) initialize.

Definition at line 251 of file DataOnDemandSvc.cpp.

                                  {
  if ( !( m_algMgr = serviceLocator() ) ) // assignment meant
  {
    error() << "Failed to retrieve the IAlgManager interface." << endmsg;
    return StatusCode::FAILURE;
  }
 
  if ( !( m_incSvc = serviceLocator()->service( "IncidentSvc" ) ) ) // assignment meant
  {
    error() << "Failed to retrieve Incident service." << endmsg;
    return StatusCode::FAILURE;
  }
  m_incSvc->addListener( this, m_trapType );
 
  if ( !( m_dataSvc = serviceLocator()->service( m_dataSvcName ) ) ) // assignment meant
  {
    error() << "Failed to retrieve the data provider interface of " << m_dataSvcName << endmsg;
    return StatusCode::FAILURE;
  }
 
  // No need to get the ToolSvc if we are not using tools
  if ( !( m_nodeMapTools.empty() && m_algMapTools.empty() ) ) {
    if ( !( m_toolSvc = serviceLocator()->service( "ToolSvc" ) ) ) // assignment meant
    {
      error() << "Failed to retrieve ToolSvc" << endmsg;
      return StatusCode::FAILURE;
    }
 
    // load the node mapping tools
    IDODNodeMapper* nodetool = nullptr;
    for ( const auto& i : m_nodeMapTools ) {
      const StatusCode sc = m_toolSvc->retrieveTool( i, nodetool );
      if ( sc.isFailure() ) return sc;
      m_nodeMappers.push_back( nodetool );
    }
    IDODAlgMapper* algtool = nullptr;
    for ( const auto& i : m_algMapTools ) {
      const StatusCode sc = m_toolSvc->retrieveTool( i, algtool );
      if ( sc.isFailure() ) return sc;
      m_algMappers.push_back( algtool );
    }
  }
  return update();
}

◆ setupAlgHandlers()

StatusCode DataOnDemandSvc::setupAlgHandlers ( )

protected

Initialize leaf handlers.

Definition at line 321 of file DataOnDemandSvc.cpp.

                                             {
  std::string typ, tag;
 
  for ( auto alg : m_algMapping ) {
    using Parser = Gaudi::Utils::AttribStringParser;
    for ( auto attrib : Parser( alg ) ) {
      switch ( ::toupper( attrib.tag[0] ) ) {
      case 'D':
        tag = std::move( attrib.value );
        break;
      case 'T':
        typ = std::move( attrib.value );
        break;
      }
    }
    Gaudi::Utils::TypeNameString item( typ );
    if ( m_algMap.end() != m_algMap.find( tag ) || m_nodeMap.end() != m_nodeMap.find( tag ) ) {
      warning() << "The obsolete property 'Algorithms' redefines the action for '" + tag + "' to be '" + item.type() +
                       "/" + item.name() + "'"
                << endmsg;
    }
    m_algMap[tag] = item.type() + "/" + item.name();
  }
  m_updateRequired = true;
  return StatusCode::SUCCESS;
}

◆ setupNodeHandlers()

StatusCode DataOnDemandSvc::setupNodeHandlers ( )

protected

Initialize node handlers.

Definition at line 295 of file DataOnDemandSvc.cpp.

                                              {
  std::string nam, typ, tag;
  StatusCode  sc = StatusCode::SUCCESS;
  // Setup for node leafs, where simply a constructor is called...
  for ( auto node : m_nodeMapping ) {
    using Parser = Gaudi::Utils::AttribStringParser;
    for ( auto attrib : Parser( node ) ) {
      switch ( ::toupper( attrib.tag[0] ) ) {
      case 'D':
        tag = std::move( attrib.value );
        break;
      case 'T':
        nam = std::move( attrib.value );
        break;
      }
    }
    if ( m_algMap.end() != m_algMap.find( tag ) || m_nodeMap.end() != m_nodeMap.find( tag ) ) {
      warning() << "The obsolete property 'Nodes' redefines the action for '" + tag + "' to be '" + nam + "'" << endmsg;
    }
    m_nodeMap[tag] = nam;
  }
 
  m_updateRequired = true;
 
  return sc;
}

◆ update()

StatusCode DataOnDemandSvc::update ( )

protected

update the handlers

Definition at line 116 of file DataOnDemandSvc.cpp.

                                   {
  if ( !m_updateRequired ) { return StatusCode::SUCCESS; }
 
  // convert obsolete "Nodes"      into new "NodeMap"
  StatusCode sc = setupNodeHandlers(); // convert "Nodes"      new "NodeMap"
  if ( sc.isFailure() ) {
    error() << "Failed to setup old \"Nodes\"" << endmsg;
    return sc;
  }
  // convert obsolete "Algorithms" into new "AlgMap"
  sc = setupAlgHandlers(); // convert "Algorithms" into "AlgMap"
  if ( sc.isFailure() ) {
    error() << "Failed to setup old \"Algorithms\"" << endmsg;
    return sc;
  }
  // add the default prefix
  add_prefix( m_algMap, m_prefix );
  // add the default prefix
  add_prefix( m_nodeMap, m_prefix );
  // get all directories
  std::set<std::string> dirs;
  if ( m_partialPath ) { get_dirs( m_algMap, dirs ); }
  if ( m_partialPath ) { get_dirs( m_nodeMap, dirs ); }
 
  auto _e = dirs.find( "/Event" );
  if ( dirs.end() != _e ) { dirs.erase( _e ); }
  // add all directories as nodes
  for ( const auto& dir : dirs ) {
    if ( m_algMap.end() == m_algMap.find( dir ) && m_nodeMap.end() == m_nodeMap.find( dir ) )
      m_nodeMap[dir] = "DataObject";
  }
 
  m_algs.clear();
  m_nodes.clear();
 
  // setup algorithms
  for ( const auto& alg : m_algMap ) {
    if ( i_setAlgHandler( alg.first, alg.second ).isFailure() ) return StatusCode::FAILURE;
  }
  // setup nodes
  for ( const auto& node : m_nodeMap ) { i_setNodeHandler( node.first, node.second ); }
 
  m_updateRequired = false;
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

◆ m_algMap

Gaudi::Property<Map> DataOnDemandSvc::m_algMap { this, "AlgMap", {}, &DataOnDemandSvc::force_update, "mapping {'data': 'algorithm'}" }

private

Definition at line 246 of file DataOnDemandSvc.h.

246{ this, "AlgMap", {}, &DataOnDemandSvc::force_update, "mapping {'data': 'algorithm'}" };

◆ m_algMappers

std::vector<IDODAlgMapper*> DataOnDemandSvc::m_algMappers

private

Definition at line 223 of file DataOnDemandSvc.h.

◆ m_algMapping

Gaudi::Property<Setup> DataOnDemandSvc::m_algMapping

private

Initial value:

{

this, "Algorithms", {}, &DataOnDemandSvc::deprecated_property, "[[deprecated]] use AlgMap" }

DataOnDemandSvc::deprecated_property

void deprecated_property(Gaudi::Details::PropertyBase &p)

Definition DataOnDemandSvc.h:190

Definition at line 240 of file DataOnDemandSvc.h.

240 {

241 this, "Algorithms", {}, &DataOnDemandSvc::deprecated_property, "[[deprecated]] use AlgMap" };

◆ m_algMapTools

Gaudi::Property<std::vector<std::string> > DataOnDemandSvc::m_algMapTools

private

Initial value:

{

this, "AlgMappingTools", {}, "list of tools of type IDODAlgMapper" }

Definition at line 253 of file DataOnDemandSvc.h.

253 {

254 this, "AlgMappingTools", {}, "list of tools of type IDODAlgMapper" };

◆ m_algMgr

SmartIF<IAlgManager> DataOnDemandSvc::m_algMgr = nullptr

private

Algorithm manager.

Definition at line 198 of file DataOnDemandSvc.h.

◆ m_algs

AlgMap DataOnDemandSvc::m_algs

private

Map of algorithms to handle incidents.

Definition at line 204 of file DataOnDemandSvc.h.

◆ m_allowInitFailure

Gaudi::Property<bool> DataOnDemandSvc::m_allowInitFailure

private

Initial value:

{
      this, "AllowPreInitializeFailure", false,
      "allow (pre)initialization of algorithms to fail without stopping the application" }

Definition at line 236 of file DataOnDemandSvc.h.

                                        {
      this, "AllowPreInitializeFailure", false,
      "allow (pre)initialization of algorithms to fail without stopping the application" };

◆ m_dataSvc

SmartIF<IDataProviderSvc> DataOnDemandSvc::m_dataSvc = nullptr

private

Data provider reference.

Definition at line 200 of file DataOnDemandSvc.h.

◆ m_dataSvcName

Gaudi::Property<std::string> DataOnDemandSvc::m_dataSvcName { this, "DataSvc", "EventDataSvc", "DataSvc name" }

private

Definition at line 226 of file DataOnDemandSvc.h.

226{ this, "DataSvc", "EventDataSvc", "DataSvc name" };

◆ m_dump

Gaudi::Property<bool> DataOnDemandSvc::m_dump

private

Initial value:

{
      this, "Dump", false,
      [this]( auto& ) {
        if ( m_dump && FSMState() >= Gaudi::StateMachine::INITIALIZED ) { dump( MSG::ALWAYS ); }
      },
      "dump configuration and stastics, if set to True after initialize it triggers a dump immediately" }

Definition at line 229 of file DataOnDemandSvc.h.

                            {
      this, "Dump", false,
      [this]( auto& ) {
        if ( m_dump && FSMState() >= Gaudi::StateMachine::INITIALIZED ) { dump( MSG::ALWAYS ); }
      },
      "dump configuration and stastics, if set to True after initialize it triggers a dump immediately" };

◆ m_incSvc

SmartIF<IIncidentSvc> DataOnDemandSvc::m_incSvc = nullptr

private

Incident service.

Definition at line 196 of file DataOnDemandSvc.h.

◆ m_init

Gaudi::Property<bool> DataOnDemandSvc::m_init { this, "PreInitialize", false, "(pre)initialize all algorithms" }

private

Definition at line 235 of file DataOnDemandSvc.h.

235{ this, "PreInitialize", false, "(pre)initialize all algorithms" };

◆ m_locked_algs

bool DataOnDemandSvc::m_locked_algs = false

private

Definition at line 219 of file DataOnDemandSvc.h.

◆ m_locked_all

bool DataOnDemandSvc::m_locked_all = false

private

Definition at line 220 of file DataOnDemandSvc.h.

◆ m_locked_nodes

bool DataOnDemandSvc::m_locked_nodes = false

private

Definition at line 218 of file DataOnDemandSvc.h.

◆ m_nodeMap

Gaudi::Property<Map> DataOnDemandSvc::m_nodeMap { this, "NodeMap", {}, &DataOnDemandSvc::force_update, "mapping {'data': 'type'}" }

private

Definition at line 247 of file DataOnDemandSvc.h.

247{ this, "NodeMap", {}, &DataOnDemandSvc::force_update, "mapping {'data': 'type'}" };

◆ m_nodeMappers

std::vector<IDODNodeMapper*> DataOnDemandSvc::m_nodeMappers

private

Definition at line 222 of file DataOnDemandSvc.h.

◆ m_nodeMapping

Gaudi::Property<Setup> DataOnDemandSvc::m_nodeMapping

private

Initial value:

{

this, "Nodes", {}, &DataOnDemandSvc::deprecated_property, "[[deprecated]] use NodeMap" }

Definition at line 242 of file DataOnDemandSvc.h.

242 {

243 this, "Nodes", {}, &DataOnDemandSvc::deprecated_property, "[[deprecated]] use NodeMap" };

◆ m_nodeMapTools

Gaudi::Property<std::vector<std::string> > DataOnDemandSvc::m_nodeMapTools

private

Initial value:

{

this, "NodeMappingTools", {}, "list of tools of type IDODNodeMapper" }

Definition at line 251 of file DataOnDemandSvc.h.

251 {

252 this, "NodeMappingTools", {}, "list of tools of type IDODNodeMapper" };

◆ m_nodes

NodeMap DataOnDemandSvc::m_nodes

private

Map of "empty" objects to be placed as intermediate nodes.

Definition at line 206 of file DataOnDemandSvc.h.

◆ m_partialPath

Gaudi::Property<bool> DataOnDemandSvc::m_partialPath { this, "UsePreceedingPath", true, "allow creation of partial leaves" }

private

Definition at line 228 of file DataOnDemandSvc.h.

228{ this, "UsePreceedingPath", true, "allow creation of partial leaves" };

◆ m_prefix

Gaudi::Property<std::string> DataOnDemandSvc::m_prefix { this, "Prefix", "/Event/" }

private

Definition at line 249 of file DataOnDemandSvc.h.

249{ this, "Prefix", "/Event/" };

◆ m_stat

unsigned long long DataOnDemandSvc::m_stat = 0

private

Definition at line 213 of file DataOnDemandSvc.h.

◆ m_statAlg

unsigned long long DataOnDemandSvc::m_statAlg = 0

private

Definition at line 211 of file DataOnDemandSvc.h.

◆ m_statNode

unsigned long long DataOnDemandSvc::m_statNode = 0

private

Definition at line 212 of file DataOnDemandSvc.h.

◆ m_timer_algs

ChronoEntity DataOnDemandSvc::m_timer_algs

private

Definition at line 216 of file DataOnDemandSvc.h.

◆ m_timer_all

ChronoEntity DataOnDemandSvc::m_timer_all

private

Definition at line 217 of file DataOnDemandSvc.h.

◆ m_timer_nodes

ChronoEntity DataOnDemandSvc::m_timer_nodes

private

Definition at line 215 of file DataOnDemandSvc.h.

◆ m_toolSvc

SmartIF<IToolSvc> DataOnDemandSvc::m_toolSvc

private

Data provider reference.

Definition at line 202 of file DataOnDemandSvc.h.

◆ m_total

ChronoEntity DataOnDemandSvc::m_total

private

Definition at line 210 of file DataOnDemandSvc.h.

◆ m_trapType

Gaudi::Property<std::string> DataOnDemandSvc::m_trapType { this, "IncidentName", "DataFault", "the type of handled Incident" }

private

Definition at line 225 of file DataOnDemandSvc.h.

225{ this, "IncidentName", "DataFault", "the type of handled Incident" };

◆ m_updateRequired

bool DataOnDemandSvc::m_updateRequired = true

private

Definition at line 208 of file DataOnDemandSvc.h.

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

GaudiCoreSvc/src/IncidentSvc/DataOnDemandSvc.h
GaudiCoreSvc/src/IncidentSvc/DataOnDemandSvc.cpp

Classes

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ AlgMap

◆ ClassH

◆ Map

◆ NodeMap

◆ Setup

Member Function Documentation

◆ configureHandler()

◆ deprecated_property()

◆ dump()

◆ execHandler() [1/2]

◆ execHandler() [2/2]

◆ finalize()

◆ force_update()

◆ handle()

◆ i_setAlgHandler()

◆ i_setNodeHandler()

◆ initialize()

◆ reinitialize()

◆ setup()

◆ setupAlgHandlers()

◆ setupNodeHandlers()

◆ update()

Member Data Documentation

◆ m_algMap

◆ m_algMappers

◆ m_algMapping

◆ m_algMapTools

◆ m_algMgr

◆ m_algs

◆ m_allowInitFailure

◆ m_dataSvc

◆ m_dataSvcName

◆ m_dump

◆ m_incSvc

◆ m_init

◆ m_locked_algs

◆ m_locked_all

◆ m_locked_nodes

◆ m_nodeMap

◆ m_nodeMappers

◆ m_nodeMapping

◆ m_nodeMapTools

◆ m_nodes

◆ m_partialPath

◆ m_prefix

◆ m_stat

◆ m_statAlg

◆ m_statNode

◆ m_timer_algs

◆ m_timer_all

◆ m_timer_nodes

◆ m_toolSvc

◆ m_total

◆ m_trapType

◆ m_updateRequired