| The Gaudi Framework v28r2p1 (f1a77ff4)

- 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/SmartIF.h"
22 #include "GaudiKernel/ObjectFactory.h"
23 #include "GaudiKernel/ISvcManager.h"
24 #include "GaudiKernel/IRndmEngine.h"
25
26
27 #include "RndmGen.h"
28 #include "RndmGenSvc.h"
29
30 // Instantiation of a static factory class used by clients to create
31 // instances of this service
32 DECLARE_COMPONENT(RndmGenSvc)
33
34 StatusCode RndmGenSvc::initialize() {
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 StatusCode status = Service::finalize();
71 m_serialize.reset();
72 if ( m_engine ) {
73 m_engine.as<IService>()->finalize().ignore();
74 m_engine.reset();
75 }
76 return status;
77 }
78
80 StreamBuffer& RndmGenSvc::serialize(StreamBuffer& str) {
82 if ( m_serialize ) return m_serialize->serialize(str);
83 error() << "Cannot input serialize Generator settings!" << endmsg;
84 return str;
85 }
86
88 StreamBuffer& RndmGenSvc::serialize(StreamBuffer& str) const {
89 if ( m_serialize ) return m_serialize->serialize(str);
90 error() << "Cannot output serialize Generator settings!" << endmsg;
91 return str;
92 }
93
95 IRndmEngine* RndmGenSvc::engine() {
96 return m_engine.get();
97 }
98
100 StatusCode RndmGenSvc::generator(const IRndmGen::Param& par, IRndmGen*& refpGen) {
101 auto pGen = SmartIF<IRndmGen>( ObjFactory::create(par.type(),m_engine.get()) );
102 if (!pGen) {
103 refpGen = nullptr;
104 return StatusCode::FAILURE;
105 }
106 refpGen = pGen.get();
107 refpGen->addRef(); // insure the caller gets something with a refCount of (at least) one back...
108 return refpGen->initialize(par);
109 }
110
111 // Single shot returning single random number
112 double RndmGenSvc::rndm() const {
113 return m_engine ? m_engine->rndm() : -1;
114 }
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 return m_engine ? m_engine->rndmArray(array, howmany, start)
124 : StatusCode::FAILURE;
125 }
126
127 // Allow to set new seeds
128 StatusCode RndmGenSvc::setSeeds(const std::vector<long>& seeds) {
129 return m_engine ? m_engine->setSeeds(seeds)
130 : StatusCode::FAILURE;
131 }
132
133 // Allow to get the seeds
134 StatusCode RndmGenSvc::seeds(std::vector<long>& seeds) const {
135 return m_engine ? m_engine->seeds(seeds)
136 : 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:81
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:28
StatusCode::FAILURE
Definition: StatusCode.h:29
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:50
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:74
IRndmGen
Definition of a interface for a generic random number generators.
Definition: IRndmGen.h:35
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:36
std::string
STL class.
RndmGenSvc
Random Generator service definition.
Definition: RndmGenSvc.h:49
SmartIF::get
TYPE * get() const
Get interface pointer.
Definition: SmartIF.h:76
IRndmEngine.h
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:117
SmartIF::as
SmartIF< IFace > as() const
return a new SmartIF instance to another interface
Definition: SmartIF.h:110
Gaudi::Utils::TypeNameString
Helper class to parse a string of format "type/name".
Definition: TypeNameString.h:12
compareOutputFiles.par
string par
Definition: compareOutputFiles.py:386
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:112
SmartIF.h
RndmGenSvc::generator
StatusCode generator(const IRndmGen::Param &par, IRndmGen *&refpGen) override
Retrieve a valid generator from the service.
Definition: RndmGenSvc.cpp:100
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:27
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:30
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:88
RndmGenSvc::engine
IRndmEngine * engine() override
Retrieve engine.
Definition: RndmGenSvc.cpp:95
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:106
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:244