| The Gaudi Framework v30r0 (c919700c)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

RndmGenSvc.cpp
Go to the documentation of this file.
1 //====================================================================
2 // Random Generator service implementation
3 //--------------------------------------------------------------------
4 //
5 // Package : Gaudi/RndmGen ( The LHCb Offline System)
6 // Author : M.Frank
7 // History :
8 // +---------+----------------------------------------------+---------
9 // | Date | Comment | Who
10 // +---------+----------------------------------------------+---------
11 // | 29/10/99| Initial version | MF
12 // +---------+----------------------------------------------+---------
13 //
14 //====================================================================
15 #define GAUDI_RANDOMGENSVC_RNDMGENSVC_CPP
16
17 // STL include files
18 #include <cfloat>
19
20 // Framework include files
21 #include "GaudiKernel/IRndmEngine.h"
22 #include "GaudiKernel/ISvcManager.h"
23 #include "GaudiKernel/ObjectFactory.h"
24 #include "GaudiKernel/SmartIF.h"
25
26 #include "RndmGen.h"
27 #include "RndmGenSvc.h"
28
29 // Instantiation of a static factory class used by clients to create
30 // instances of this service
31 DECLARE_COMPONENT( RndmGenSvc )
32
33 StatusCode RndmGenSvc::initialize()
35 {
36 StatusCode status = Service::initialize();
37
38 auto mgr = serviceLocator()->as<ISvcManager>();
39
40 if ( status.isSuccess() ) {
41 status = setProperties();
42 if ( status.isSuccess() ) { // Check if the Engine service exists:
43 // FIXME: (MCl) why RndmGenSvc cannot create the engine service in a standard way?
44 const bool CREATE = false;
45 std::string machName = name() + ".Engine";
46 auto engine = serviceLocator()->service<IRndmEngine>( machName, CREATE );
47 if ( !engine && mgr ) {
48 using Gaudi::Utils::TypeNameString;
49 engine = mgr->createService( TypeNameString( machName, m_engineName ) );
50 }
51 if ( engine ) {
52 auto serial = engine.as<ISerialize>();
53 auto service = engine.as<IService>();
54 if ( serial && service ) {
55 status = service->sysInitialize();
56 if ( status.isSuccess() ) {
57 m_engine = engine;
58 m_serialize = serial;
59 info() << "Using Random engine:" << m_engineName.value() << endmsg;
60 }
61 }
62 }
63 }
64 }
65 return status;
66 }
67
69 StatusCode RndmGenSvc::finalize()
70 {
71 StatusCode status = Service::finalize();
72 m_serialize.reset();
73 if ( m_engine ) {
74 m_engine.as<IService>()->finalize().ignore();
75 m_engine.reset();
76 }
77 return status;
78 }
79
81 StreamBuffer& RndmGenSvc::serialize( StreamBuffer& str )
83 {
84 if ( m_serialize ) return m_serialize->serialize( str );
85 error() << "Cannot input serialize Generator settings!" << endmsg;
86 return str;
87 }
88
90 StreamBuffer& RndmGenSvc::serialize( StreamBuffer& str ) const
91 {
92 if ( m_serialize ) return m_serialize->serialize( str );
93 error() << "Cannot output serialize Generator settings!" << endmsg;
94 return str;
95 }
96
98 IRndmEngine* RndmGenSvc::engine() { return m_engine.get(); }
99
101 StatusCode RndmGenSvc::generator( const IRndmGen::Param& par, IRndmGen*& refpGen )
102 {
103 auto pGen = SmartIF<IRndmGen>( ObjFactory::create( par.type(), m_engine.get() ) );
104 if ( !pGen ) {
105 refpGen = nullptr;
106 return StatusCode::FAILURE;
107 }
108 refpGen = pGen.get();
109 refpGen->addRef(); // insure the caller gets something with a refCount of (at least) one back...
110 return refpGen->initialize( par );
111 }
112
113 // Single shot returning single random number
114 double RndmGenSvc::rndm() const { return m_engine ? m_engine->rndm() : -1; }
115
116 /* Multiple shots returning vector with flat random numbers.
117 @param array Array containing random numbers
118 @param howmany fill 'howmany' random numbers into array
119 @param start ... starting at position start
120 @return StatusCode indicating failure or success.
121 */
122 StatusCode RndmGenSvc::rndmArray( std::vector<double>& array, long howmany, long start ) const
123 {
124 return m_engine ? m_engine->rndmArray( array, howmany, start ) : StatusCode::FAILURE;
125 }
126
127 // Allow to set new seeds
128 StatusCode RndmGenSvc::setSeeds( const std::vector<long>& seeds )
129 {
130 return m_engine ? m_engine->setSeeds( seeds ) : StatusCode::FAILURE;
131 }
132
133 // Allow to get the seeds
134 StatusCode RndmGenSvc::seeds( std::vector<long>& seeds ) const
135 {
136 return m_engine ? m_engine->seeds( seeds ) : StatusCode::FAILURE;
137 }
IRndmGen::initialize
virtual StatusCode initialize(const IRndmGen::Param &par)=0
Initialize the generator.
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:64
IRndmEngine::seeds
virtual StatusCode seeds(std::vector< long > &seeds) const =0
Allow to retrieve seeds.
RndmGenSvc.h
SmartIF< IRndmGen >
RndmGenSvc::serialize
StreamBuffer & serialize(StreamBuffer &str) override
IRndmGenSvc interface implementation.
Definition: RndmGenSvc.cpp:82
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:32
Service::finalize
StatusCode finalize() override
Definition: Service.cpp:174
RndmGenSvc::finalize
StatusCode finalize() override
Service override: finalization.
Definition: RndmGenSvc.cpp:69
Service::start
StatusCode start() override
Definition: Service.cpp:137
IRndmEngine::rndm
virtual double rndm() const =0
Single shot returning single random number.
ISvcManager
The ISvcManager is the interface implemented by the Service Factory in the Application Manager to sup...
Definition: ISvcManager.h:28
StreamBuffer
The stream buffer is a small object collecting object data.
Definition: StreamBuffer.h:41
IRndmGen::Param::type
virtual const InterfaceID & type() const
Parameter&#39;s type.
Definition: IRndmGen.h:52
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:50
IRndmGen
Definition of a interface for a generic random number generators.
Definition: IRndmGen.h:34
RndmGenSvc::m_engine
SmartIF< IRndmEngine > m_engine
Random number engine.
Definition: RndmGenSvc.h:53
ObjectFactory.h
ISvcManager.h
DECLARE_COMPONENT
#define DECLARE_COMPONENT(type)
Definition: PluginService.h:33
std::string
STL class.
RndmGenSvc
Random Generator service definition.
Definition: RndmGenSvc.h:49
SmartIF::get
TYPE * get() const
Get interface pointer.
Definition: SmartIF.h:82
IRndmEngine.h
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:106
SmartIF::as
SmartIF< IFace > as() const
return a new SmartIF instance to another interface
Definition: SmartIF.h:115
Gaudi::Utils::TypeNameString
Helper class to parse a string of format "type/name".
Definition: TypeNameString.h:12
compareOutputFiles.par
string par
Definition: compareOutputFiles.py:437
IService
General service interface definition.
Definition: IService.h:18
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
IRndmGen::Param
Definition: IRndmGen.h:40
ISerialize::serialize
virtual StreamBuffer & serialize(StreamBuffer &str)=0
Input serialization from stream buffer.
RndmGenSvc::rndm
double rndm() const override
Single shot returning single random number.
Definition: RndmGenSvc.cpp:114
SmartIF.h
RndmGenSvc::generator
StatusCode generator(const IRndmGen::Param &par, IRndmGen *&refpGen) override
Retrieve a valid generator from the service.
Definition: RndmGenSvc.cpp:101
IRndmEngine::setSeeds
virtual StatusCode setSeeds(const std::vector< long > &seeds)=0
Allow to set new seeds.
RndmGen.h
Containers::array
struct GAUDI_API array
Parametrisation class for redirection array - like implementation.
Definition: KeyedObjectManager.h:28
std::vector< double >
RndmGenSvc::setSeeds
StatusCode setSeeds(const std::vector< long > &seeds) override
Allow to set new seeds.
Definition: RndmGenSvc.cpp:128
RndmGenSvc::rndmArray
StatusCode rndmArray(std::vector< double > &array, long howmany, long start=0) const override
Multiple shots returning vector with flat random numbers.
Definition: RndmGenSvc.cpp:122
Io::CREATE
Definition: IFileMgr.h:31
IInterface::addRef
virtual unsigned long addRef()=0
Increment the reference count of Interface instance.
RndmGenSvc::seeds
StatusCode seeds(std::vector< long > &seeds) const override
Allow to get seeds.
Definition: RndmGenSvc.cpp:134
IRndmEngine
Definition of a interface for a generic random number generator giving randomly distributed numbers i...
Definition: IRndmEngine.h:19
SmartIF::reset
void reset(TYPE *ptr=nullptr)
Set the internal pointer to the passed one disposing of the old one.
Definition: SmartIF.h:92
RndmGenSvc::engine
IRndmEngine * engine() override
Retrieve engine.
Definition: RndmGenSvc.cpp:98
StatusCode::FAILURE
Definition: StatusCode.h:29
IRndmEngine::rndmArray
virtual StatusCode rndmArray(std::vector< double > &array, long howmany, long start=0) const =0
Multiple shots returning vector with flat random numbers.
RndmGenSvc::m_serialize
SmartIF< ISerialize > m_serialize
Serialization interface of random number engine.
Definition: RndmGenSvc.h:55
StatusCode::ignore
void ignore() const
Definition: StatusCode.h:84
ISerialize
Object serialization interface definition.
Definition: ISerialize.h:17
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209