| The Gaudi Framework v27r1

- 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 RndmGenSvc::RndmGenSvc(const std::string& nam, ISvcLocator* svc)
36 : base_class(nam, svc)
37 {
38 declareProperty("Engine", m_engineName = "HepRndm::Engine<CLHEP::RanluxEngine>");
39 }
40
42 StatusCode RndmGenSvc::initialize() {
43 StatusCode status = Service::initialize();
44
45 auto mgr = serviceLocator()->as<ISvcManager>();
46
47 if ( status.isSuccess() ) {
48 status = setProperties();
49 if ( status.isSuccess() ) { // Check if the Engine service exists:
50 // FIXME: (MCl) why RndmGenSvc cannot create the engine service in a standard way?
51 const bool CREATE = false;
52 std::string machName = name()+".Engine";
53 auto engine = serviceLocator()->service<IRndmEngine>(machName, CREATE);
54 if ( !engine && mgr ) {
55 using Gaudi::Utils::TypeNameString;
56 engine = mgr->createService(TypeNameString(machName, m_engineName));
57 }
58 if ( engine ) {
59 auto serial = engine.as<ISerialize>();
60 auto service = engine.as<IService>();
61 if ( serial && service ) {
62 status = service->sysInitialize();
63 if ( status.isSuccess() ) {
64 m_engine = engine;
65 m_serialize = serial;
66 info() << "Using Random engine:" << m_engineName << endmsg;
67 }
68 }
69 }
70 }
71 }
72 return status;
73 }
74
76 StatusCode RndmGenSvc::finalize() {
77 StatusCode status = Service::finalize();
78 m_serialize.reset();
79 if ( m_engine ) {
80 m_engine.as<IService>()->finalize().ignore();
81 m_engine.reset();
82 }
83 return status;
84 }
85
87 StreamBuffer& RndmGenSvc::serialize(StreamBuffer& str) {
89 if ( m_serialize ) return m_serialize->serialize(str);
90 error() << "Cannot input serialize Generator settings!" << endmsg;
91 return str;
92 }
93
95 StreamBuffer& RndmGenSvc::serialize(StreamBuffer& str) const {
96 if ( m_serialize ) return m_serialize->serialize(str);
97 error() << "Cannot output serialize Generator settings!" << endmsg;
98 return str;
99 }
100
102 IRndmEngine* RndmGenSvc::engine() {
103 return m_engine.get();
104 }
105
107 StatusCode RndmGenSvc::generator(const IRndmGen::Param& par, IRndmGen*& refpGen) {
108 auto pGen = SmartIF<IRndmGen>( ObjFactory::create(par.type(),m_engine.get()) );
109 if (!pGen) {
110 refpGen = nullptr;
111 return StatusCode::FAILURE;
112 }
113 refpGen = pGen.get();
114 refpGen->addRef(); // insure the caller gets something with a refCount of (at least) one back...
115 return refpGen->initialize(par);
116 }
117
118 // Single shot returning single random number
119 double RndmGenSvc::rndm() const {
120 return m_engine ? m_engine->rndm() : -1;
121 }
122
123 /* Multiple shots returning vector with flat random numbers.
124 @param array Array containing random numbers
125 @param howmany fill 'howmany' random numbers into array
126 @param start ... starting at position start
127 @return StatusCode indicating failure or success.
128 */
129 StatusCode RndmGenSvc::rndmArray( std::vector<double>& array, long howmany, long start) const {
130 return m_engine ? m_engine->rndmArray(array, howmany, start)
131 : StatusCode::FAILURE;
132 }
133
134 // Allow to set new seeds
135 StatusCode RndmGenSvc::setSeeds(const std::vector<long>& seeds) {
136 return m_engine ? m_engine->setSeeds(seeds)
137 : StatusCode::FAILURE;
138 }
139
140 // Allow to get the seeds
141 StatusCode RndmGenSvc::seeds(std::vector<long>& seeds) const {
142 return m_engine ? m_engine->seeds(seeds)
143 : StatusCode::FAILURE;
144 }
145
IRndmGen::initialize
virtual StatusCode initialize(const IRndmGen::Param &par)=0
Initialize the generator.
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:68
RndmGenSvc.h
SmartIF< IRndmGen >
Service::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Retrieve pointer to service locator.
Definition: Service.cpp:324
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::serialize
StreamBuffer & serialize(StreamBuffer &str) override
IRndmGenSvc interface implementation.
Definition: RndmGenSvc.cpp:88
ISvcLocator
The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to loc...
Definition: ISvcLocator.h:25
RndmGenSvc::initialize
StatusCode initialize() override
Service override: initialization.
Definition: RndmGenSvc.cpp:42
Service::finalize
StatusCode finalize() override
Definition: Service.cpp:193
CommonMessagingBase::info
MsgStream & info() const
shortcut for the method msgStream(MSG::INFO)
Definition: CommonMessaging.h:124
RndmGenSvc::finalize
StatusCode finalize() override
Service override: finalization.
Definition: RndmGenSvc.cpp:76
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's type.
Definition: IRndmGen.h:50
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:76
IRndmGen
Definition of a interface for a generic random number generators.
Definition: IRndmGen.h:35
RndmGenSvc::m_engineName
std::string m_engineName
Engine name.
Definition: RndmGenSvc.h:59
RndmGenSvc::m_engine
SmartIF< IRndmEngine > m_engine
Random number engine.
Definition: RndmGenSvc.h:55
ObjectFactory.h
std
STL namespace.
ISvcLocator::as
SmartIF< IFace > as()
Definition: ISvcLocator.h:106
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
ISvcLocator::service
StatusCode service(const Gaudi::Utils::TypeNameString &name, T *&svc, bool createIf=true)
Templated method to access a service by name.
Definition: ISvcLocator.h:78
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:319
IRndmEngine.h
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:118
SmartIF::as
SmartIF< IFace > as() const
return a new SmartIF instance to another interface
Definition: SmartIF.h:110
compareOutputFiles.par
string par
Definition: compareOutputFiles.py:386
Gaudi::Utils::TypeNameString
Helper class to parse a string of format "type/name".
Definition: TypeNameString.h:9
StatusCode::FAILURE
Definition: StatusCode.h:29
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
IRndmEngine::rndm
virtual double rndm() const =0
Single shot returning single random number.
IRndmGen::Param
Definition: IRndmGen.h:40
ISerialize::serialize
virtual StreamBuffer & serialize(StreamBuffer &str)=0
Input serialization from stream buffer.
SmartIF.h
RndmGenSvc::seeds
StatusCode seeds(std::vector< long > &seeds) const override
Allow to get seeds.
Definition: RndmGenSvc.cpp:141
RndmGenSvc::generator
StatusCode generator(const IRndmGen::Param &par, IRndmGen *&refpGen) override
Retrieve a valid generator from the service.
Definition: RndmGenSvc.cpp:107
IRndmEngine::setSeeds
virtual StatusCode setSeeds(const std::vector< long > &seeds)=0
Allow to set new seeds.
RndmGen.h
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:129
Service::setProperties
StatusCode setProperties()
Method for setting declared properties to the values specified for the job.
Definition: Service.cpp:363
RndmGenSvc::rndm
double rndm() const override
Single shot returning single random number.
Definition: RndmGenSvc.cpp:119
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:135
Io::CREATE
Definition: IFileMgr.h:30
IInterface::addRef
virtual unsigned long addRef()=0
Increment the reference count of Interface instance.
Service::service
StatusCode service(const std::string &name, const T *&psvc, bool createIf=true) const
Access a service by name, creating it if it doesn't already exist.
Definition: Service.h:144
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:102
RndmGenSvc::m_serialize
SmartIF< ISerialize > m_serialize
Serialization interface of random number engine.
Definition: RndmGenSvc.h:57
StatusCode::ignore
void ignore() const
Definition: StatusCode.h:108
ISerialize
Object serialization interface definition.
Definition: ISerialize.h:17
IRndmEngine::seeds
virtual StatusCode seeds(std::vector< long > &seeds) const =0
Allow to retrieve seeds.
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244
IOTest.start
tuple start
Definition: IOTest.py:88