Algorithm.h
Go to the documentation of this file.
1 #ifndef GAUDIKERNEL_ALGORITHM_H
2 #define GAUDIKERNEL_ALGORITHM_H
3 // ============================================================================
4 // Include files
5 // ============================================================================
6 #include "GaudiKernel/IProperty.h"
7 #include "GaudiKernel/IAlgorithm.h"
8 #include "GaudiKernel/IService.h"
9 #include "GaudiKernel/PropertyMgr.h"
10 #include "GaudiKernel/ISvcLocator.h"
11 #include "GaudiKernel/IMessageSvc.h"
12 #include "GaudiKernel/IStateful.h"
13 
14 #include <string>
15 #include <vector>
16 
17 // Extra include files (forward declarations should be sufficient)
18 #include "GaudiKernel/IDataProviderSvc.h"
19 #include "GaudiKernel/IHistogramSvc.h"
20 #include "GaudiKernel/IConversionSvc.h"
21 #include "GaudiKernel/INTupleSvc.h"
22 #include "GaudiKernel/IChronoStatSvc.h"
23 #include "GaudiKernel/IRndmGenSvc.h"
24 #include "GaudiKernel/IAuditorSvc.h"
25 #include "GaudiKernel/IToolSvc.h"
26 #include "GaudiKernel/IMonitorSvc.h"
27 #include "GaudiKernel/IExceptionSvc.h"
28 #include "GaudiKernel/IAlgContextSvc.h"
29 #include "GaudiKernel/Property.h"
30 #include <Gaudi/PluginService.h>
31 
32 #ifndef PACKAGE_VERSION
33 #define PACKAGE_VERSION "unknown"
34 #endif
35 
61 class GAUDI_API Algorithm: public implements3<IAlgorithm, IProperty, IStateful> {
62 public:
63 #ifndef __REFLEX__
64  typedef Gaudi::PluginService::Factory<IAlgorithm*,
65  const std::string&,
66  ISvcLocator*> Factory;
67 #endif
68 
73  Algorithm( const std::string& name, ISvcLocator *svcloc,
74  const std::string& version=PACKAGE_VERSION );
76  ~Algorithm() override = default;
77 
83  StatusCode sysStart() override;
84 
90  StatusCode sysInitialize() override;
91 
92 
98  StatusCode sysReinitialize() override;
99 
104  StatusCode sysRestart() override;
105 
113  StatusCode sysExecute() override;
114 
118  StatusCode sysStop() override;
119 
124  StatusCode sysFinalize() override;
125 
131  StatusCode sysBeginRun( ) override;
132 
138  StatusCode sysEndRun( ) override;
139 
147  const std::string& name() const override;
148 
149  const std::string& version() const override;
150 
152  StatusCode configure() override { return StatusCode::SUCCESS ; }
154  StatusCode terminate() override { return StatusCode::SUCCESS ; }
155 
157  StatusCode initialize() override { return StatusCode::SUCCESS ; }
159  StatusCode start() override { return StatusCode::SUCCESS ; }
161  StatusCode stop() override { return StatusCode::SUCCESS ; }
163  StatusCode finalize() override { return StatusCode::SUCCESS ; }
165  StatusCode reinitialize() override;
167  StatusCode restart() override;
169  Gaudi::StateMachine::State FSMState() const override { return m_state; }
171  Gaudi::StateMachine::State targetFSMState() const override { return m_targetState; }
172 
174  bool isExecuted( ) const override;
175 
177  void setExecuted( bool state ) override;
178 
182  void resetExecuted( ) override;
183 
187  StatusCode beginRun() override;
188 
190  StatusCode endRun() override;
191 
192 
194  bool isEnabled( ) const override;
195 
197  bool filterPassed( ) const override;
198 
200  void setFilterPassed( bool state ) override;
201 
203  inline int errorCount() const { return m_errorCount; }
204 
206  template <class T>
207  StatusCode service
208  ( const std::string& name, T*& psvc, bool createIf = true ) const {
209  return service_i(name, createIf, T::interfaceID(), (void**)&psvc);
210  }
211 
213  template <class T>
214  StatusCode service( const std::string& svcType, const std::string& svcName,
215  T*& psvc) const {
216  return service_i(svcType, svcName, T::interfaceID(), (void**)&psvc);
217  }
218 
220  SmartIF<IService> service(const std::string& name, const bool createIf = true, const bool quiet = false) const;
221 
222  template <class T>
223  SmartIF<T> service( const std::string& name, bool createIf = true, bool quiet = false ) const {
224  return service(name,createIf,quiet).as<T>();
225  }
226 
228  void setOutputLevel( int level );
229 
233  SmartIF<IAuditorSvc>& auditorSvc() const;
234 
238  SmartIF<IChronoStatSvc>& chronoSvc() const;
240  SmartIF<IChronoStatSvc>& chronoStatService() const;
241 
245  SmartIF<IDataProviderSvc>& detSvc() const;
246 
248  SmartIF<IDataProviderSvc>& detDataService() const;
249 
253  SmartIF<IConversionSvc>& detCnvSvc() const;
254 
256  SmartIF<IConversionSvc>& detDataCnvService() const;
257 
261  SmartIF<IDataProviderSvc>& eventSvc() const;
263  SmartIF<IDataProviderSvc>& evtSvc () const { return eventSvc() ; }
265  SmartIF<IDataProviderSvc>& eventDataService() const;
266 
270  SmartIF<IConversionSvc>& eventCnvSvc() const;
272  SmartIF<IConversionSvc>& eventDataCnvService() const;
273 
277  SmartIF<IHistogramSvc>& histoSvc() const;
279  SmartIF<IHistogramSvc>& histogramDataService() const;
280 
285  SmartIF<IMessageSvc>& msgSvc() const;
286 
288  SmartIF<IMessageSvc>& messageService() const;
289 
293  SmartIF<INTupleSvc>& ntupleSvc() const;
294 
296  SmartIF<INTupleSvc>& ntupleService() const;
297 
301  // SmartIF<IAIDATupleSvc>& atupleSvc() const;
302 
303 
307  SmartIF<IRndmGenSvc>& randSvc() const;
308 
310  SmartIF<IToolSvc>& toolSvc() const;
311 
313  SmartIF<IExceptionSvc>& exceptionSvc() const;
314 
316  SmartIF<IAlgContextSvc>& contextSvc() const ;
317 
323  SmartIF<ISvcLocator>& serviceLocator() const;
325  SmartIF<ISvcLocator>& svcLoc () const { return serviceLocator() ; }
326 
328  bool registerContext() const { return m_registerContext ; }
329 
342  StatusCode createSubAlgorithm( const std::string& type,
343  const std::string& name, Algorithm*& pSubAlg );
344 
346  const std::vector<Algorithm*>* subAlgorithms() const;
347 
349  std::vector<Algorithm*>* subAlgorithms() ;
350 
352  StatusCode setProperty( const Property& p ) override;
354  StatusCode setProperty( const std::string& s ) override;
356  StatusCode setProperty( const std::string& n, const std::string& v) override;
358  StatusCode getProperty(Property* p) const override;
360  const Property& getProperty( const std::string& name) const override;
362  StatusCode getProperty( const std::string& n, std::string& v ) const override;
364  const std::vector<Property*>& getProperties( ) const override;
366  bool hasProperty(const std::string& name) const override;
367 
375  StatusCode setProperties();
376  // ==========================================================================
406  template <class T>
407  Property* declareProperty
408  ( const std::string& name ,
409  T& property ,
410  const std::string& doc = "none" ) const
411  {
412  return m_propertyMgr->declareProperty(name, property, doc);
413  }
414  // ==========================================================================
416  Property* declareRemoteProperty
417  ( const std::string& name ,
418  IProperty* rsvc ,
419  const std::string& rname = "" ) const
420  {
421  return m_propertyMgr -> declareRemoteProperty ( name , rsvc , rname );
422  }
423  // ==========================================================================
433  inline SmartIF<IMonitorSvc>& monitorSvc() const
434  {
435  // If not already located try to locate it without forcing a creation
436  if ( !m_pMonitorSvc ){
437  m_pMonitorSvc = service(m_monitorSvcName, false, true); // do not create and be quiet
438  }
439  return m_pMonitorSvc;
440  }
441 
447  template <class T>
448  void declareInfo( const std::string& name,
449  const T& var,
450  const std::string& desc ) const
451  {
452  IMonitorSvc* mS = monitorSvc().get();
453  if ( mS ) mS->declareInfo(name, var, desc, this);
454  }
455 
463  void declareInfo( const std::string& name,
464  const std::string& format,
465  const void* var,
466  int size,
467  const std::string& desc ) const
468  {
469  IMonitorSvc* mS = monitorSvc().get();
470  if ( mS ) mS->declareInfo(name, format, var, size, desc, this);
471  }
472 
473  // ==========================================================================
474 public:
475  // ==========================================================================
517  template <class TYPE>
518  StatusCode setProperty
519  ( const std::string& name ,
520  const TYPE& value )
521  { return Gaudi::Utils::setProperty ( m_propertyMgr.get() , name , value ) ; }
522  // ==========================================================================
523 protected:
524 
526  bool isInitialized( ) const override { return Gaudi::StateMachine::INITIALIZED == m_state; }
527 
529  bool isFinalized( ) const override{ return Gaudi::StateMachine::CONFIGURED == m_state; }
530 
532  int outputLevel() const { return (int)m_outputLevel ; }
533 
535  IntegerProperty & outputLevelProperty() { return m_outputLevel; }
536 
538  void initOutputLevel(Property& prop);
539 
540 
541 private:
542 
543  std::string m_name;
544  std::string m_version;
545  std::vector<Algorithm *> m_subAlgms;
546 
547  mutable SmartIF<IMessageSvc> m_MS;
548  mutable SmartIF<IDataProviderSvc> m_EDS;
549  mutable SmartIF<IConversionSvc> m_ECS;
550  mutable SmartIF<IDataProviderSvc> m_DDS;
551  mutable SmartIF<IConversionSvc> m_DCS;
552  mutable SmartIF<IHistogramSvc> m_HDS;
553  mutable SmartIF<INTupleSvc> m_NTS;
554  // mutable SmartIF<IAIDATupleSvc> m_ATS; ///< AIDA tuple service
555  mutable SmartIF<IChronoStatSvc> m_CSS;
556  mutable SmartIF<IRndmGenSvc> m_RGS;
557  mutable SmartIF<IExceptionSvc> m_EXS;
558  mutable SmartIF<IAuditorSvc> m_pAuditorSvc;
559  mutable SmartIF<IToolSvc> m_ptoolSvc;
560  mutable SmartIF<IMonitorSvc> m_pMonitorSvc;
561  mutable SmartIF<IAlgContextSvc> m_contextSvc ;
562  bool m_registerContext = false ;
563  std::string m_monitorSvcName;
564  SmartIF<ISvcLocator> m_pSvcLocator;
565  SmartIF<PropertyMgr> m_propertyMgr;
566  IntegerProperty m_outputLevel;
567  int m_errorMax;
568  int m_errorCount;
569  BooleanProperty m_auditInit;
570  bool m_auditorInitialize;
571  bool m_auditorReinitialize;
572  bool m_auditorRestart;
573  bool m_auditorExecute;
574  bool m_auditorFinalize;
575  bool m_auditorBeginRun;
576  bool m_auditorEndRun;
577  bool m_auditorStart;
578  bool m_auditorStop;
579  bool m_filterPassed = true;
580  bool m_isEnabled = true;
581  bool m_isExecuted = false;
582  Gaudi::StateMachine::State m_state = Gaudi::StateMachine::CONFIGURED;
583  Gaudi::StateMachine::State m_targetState = Gaudi::StateMachine::CONFIGURED;
584  bool m_isFinalized;
585 
587  StatusCode service_i(const std::string& svcName,
588  bool createIf,
589  const InterfaceID& iid,
590  void** ppSvc) const;
591  StatusCode service_i(const std::string& svcType,
592  const std::string& svcName,
593  const InterfaceID& iid,
594  void** ppSvc) const;
595 
597  Algorithm(const Algorithm& a);
598 
600  Algorithm& operator=(const Algorithm& rhs);
601 };
602 
603 #ifndef GAUDI_NEW_PLUGIN_SERVICE
604 template <class T>
605 class AlgFactory {
606 public:
607 #ifndef __REFLEX__
608  template <typename S, typename... Args>
609  static typename S::ReturnType create(Args&&... args) {
610  return new T(std::forward<Args>(args)...);
611  }
612 #endif
613 };
614 
615 // Macros to declare component factories
616 #define DECLARE_ALGORITHM_FACTORY(x) \
617  DECLARE_FACTORY_WITH_CREATOR(x, AlgFactory< x >, Algorithm::Factory)
618 #define DECLARE_NAMED_ALGORITHM_FACTORY(x, n) \
619  DECLARE_FACTORY_WITH_CREATOR_AND_ID(x, AlgFactory< x >, \
620  #n, Algorithm::Factory)
621 #define DECLARE_NAMESPACE_ALGORITHM_FACTORY(n, x) \
622  DECLARE_ALGORITHM_FACTORY(n::x)
623 
624 #else
625 
626 // Macros to declare component factories
627 #define DECLARE_ALGORITHM_FACTORY(x) DECLARE_COMPONENT(x)
628 #define DECLARE_NAMED_ALGORITHM_FACTORY(x, n) DECLARE_COMPONENT_WITH_ID(x, #n)
629 #define DECLARE_NAMESPACE_ALGORITHM_FACTORY(n, x) DECLARE_COMPONENT(n::x)
630 
631 #endif
632 
633 #endif //GAUDIKERNEL_ALGORITHM_H
Gaudi::Utils::setProperty
StatusCode setProperty(IProperty *component, const std::string &name, const TYPE &value, const std::string &doc)
simple function to set the property of the given object from the value
Definition: Property.h:1187
implements
Base class used to implement the interfaces.
Definition: implements.h:8
AnalysisTest.initialize
def initialize()
Definition: AnalysisTest.py:12
ISvcLocator
The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to loc...
Definition: ISvcLocator.h:25
GAUDI_API
#define GAUDI_API
Definition: Kernel.h:107
Gaudi::Utils::hasProperty
GAUDI_API bool hasProperty(const IProperty *p, const std::string &name)
simple function which check the existence of the property with the given name.
Definition: Property.cpp:157
Gaudi::StateMachine::State
State
Allowed states for classes implementing the state machine (ApplicationMgr, Algorithm, Service, AlgTool).
Definition: StateMachine.h:12
getProperty
const char *PyHelper() getProperty(IInterface *p, char *name)
Definition: Bootstrap.cpp:259
PACKAGE_VERSION
#define PACKAGE_VERSION
Definition: Algorithm.h:33
implements::operator=
implements & operator=(const implements &)
Assignment operator (do not touch the reference count).
Definition: implements.h:37
InterfaceID
Interface ID class.
Definition: IInterface.h:30
SmartIF::as
SmartIF< IFace > as() const
return a new SmartIF instance to another interface
Definition: SmartIF.h:110
IMonitorSvc
Definition of the IMonitorSvc interface, which publishes Gaudi variables to outside monitoring proces...
Definition: IMonitorSvc.h:21
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
setProperty
bool PyHelper() setProperty(IInterface *p, char *name, char *value)
Definition: Bootstrap.cpp:255
dump_component_properties.value
list value
Definition: dump_component_properties.py:12
IAlgorithm
The IAlgorithm is the interface implemented by the Algorithm base class.
Definition: IAlgorithm.h:19
Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:61
Property
Property base class allowing Property* collections to be "homogeneous".
Definition: Property.h:38
IMonitorSvc::declareInfo
virtual void declareInfo(const std::string &name, const bool &var, const std::string &desc, const IInterface *owner)=0
Declare monitoring information.
gaudirun.args
list args
Definition: gaudirun.py:291
Gaudi::PluginService::Factory
Class wrapping the signature for a factory with any number of arguments.
Definition: PluginService.h:47
AlgFactory::create
static S::ReturnType create(Args &&...args)
Definition: Algorithm.h:609
gaudirun.s
string s
Definition: gaudirun.py:246
IProperty
The IProperty is the basic interface for all components which have properties that can be set or get...
Definition: IProperty.h:21
format
GAUDI_API std::string format(const char *,...)
MsgStream format utility "a la sprintf(...)".
Definition: MsgStream.cpp:120
IOTest.start
tuple start
Definition: IOTest.py:88
gaudirun.type
string type
Definition: gaudirun.py:151