| # Gaudi Framework, version v21r9 |

Home |  | Generated: 3 May 2010

# RndmGenSvc.cpp

Go to the documentation of this file.

    00001 //====================================================================
    00002 //      Random Generator service implementation
    00003 //--------------------------------------------------------------------
    00004 //
    00005 //      Package    : Gaudi/RndmGen ( The LHCb Offline System)
    00006 //      Author     : M.Frank
    00007 //  History    :
    00008 // +---------+----------------------------------------------+---------
    00009 // |    Date |                 Comment                      | Who
    00010 // +---------+----------------------------------------------+---------
    00011 // | 29/10/99| Initial version                              | MF
    00012 // +---------+----------------------------------------------+---------
    00013 //
    00014 //====================================================================
    00015 #define GAUDI_RANDOMGENSVC_RNDMGENSVC_CPP
    00016
    00017 // STL include files
    00018 #include <cfloat>
    00019
    00020 // Framework include files
    00021 #include "GaudiKernel/SmartIF.h"
    00022 #include "GaudiKernel/SvcFactory.h"
    00023 #include "GaudiKernel/ISvcManager.h"
    00024 #include "GaudiKernel/IRndmEngine.h"
    00025
    00026 #include "GaudiKernel/MsgStream.h"
    00027
    00028 #include "RndmGen.h"
    00029 #include "RndmGenSvc.h"
    00030
    00031 using ROOT::Reflex::PluginService;
    00032
    00033 // Instantiation of a static factory class used by clients to create
    00034 // instances of this service
    00035 DECLARE_SERVICE_FACTORY(RndmGenSvc)
    00036
    00037
    00038 RndmGenSvc::RndmGenSvc(const std::string& nam, ISvcLocator* svc)
    00039 : base_class(nam, svc), m_engine(0), m_serialize(0)
    00040 {
    00041   declareProperty("Engine", m_engineName = "HepRndm::Engine<CLHEP::RanluxEngine>");
    00042 }
    00043
    00045 RndmGenSvc::~RndmGenSvc()   {
    00046 }
    00047
    00049 StatusCode RndmGenSvc::initialize()   {
    00050   StatusCode status = Service::initialize();
    00051   MsgStream log(msgSvc(), name());
    00052   std::string machName = name()+".Engine";
    00053   SmartIF<IRndmEngine> engine;
    00054   SmartIF<ISvcManager> mgr(serviceLocator());
    00055
    00056   if ( status.isSuccess() )   {
    00057     status = setProperties();
    00058     if ( status.isSuccess() )   {  // Check if the Engine service exists:
    00059       // FIXME: (MCl) why RndmGenSvc cannot create the engine service in a standard way?
    00060       const bool CREATE = false;
    00061       engine = serviceLocator()->service(machName, CREATE);
    00062       if ( !engine.isValid() && mgr.isValid() )   {
    00063         using Gaudi::Utils::TypeNameString;
    00064         engine = mgr->createService(TypeNameString(machName, m_engineName));
    00065       }
    00066       if ( engine.isValid() )   {
    00067         SmartIF<ISerialize> serial(engine);
    00068         SmartIF<IService>   service(engine);
    00069         if ( serial.isValid( ) && service.isValid( ) )  {
    00070           status = service->sysInitialize();
    00071           if ( status.isSuccess() )   {
    00072             m_engine = engine;
    00073             m_serialize = serial;
    00074             m_engine->addRef();
    00075             m_serialize->addRef();
    00076             log << MSG::INFO << "Using Random engine:" << m_engineName << endmsg;
    00077             return status;
    00078           }
    00079         }
    00080       }
    00081     }
    00082   }
    00083   return status;
    00084 }
    00085
    00087 StatusCode RndmGenSvc::finalize()   {
    00088   StatusCode status = Service::finalize();
    00089   if ( m_serialize ) m_serialize->release();
    00090   m_serialize = 0;
    00091   if ( m_engine ) {
    00092     SmartIF<IService> service(m_engine);
    00093     service->finalize().ignore();
    00094     m_engine->release();
    00095   }
    00096   m_engine = 0;
    00097   return status;
    00098 }
    00099
    00101
    00102 StreamBuffer& RndmGenSvc::serialize(StreamBuffer& str)    {
    00103   if ( 0 != m_serialize )    {
    00104     return m_serialize->serialize(str);
    00105   }
    00106   MsgStream log(msgSvc(), name());
    00107   log << MSG::ERROR << "Cannot input serialize Generator settings!" << endmsg;
    00108   return str;
    00109 }
    00110
    00112 StreamBuffer& RndmGenSvc::serialize(StreamBuffer& str) const    {
    00113   if ( 0 != m_serialize )    {
    00114     return m_serialize->serialize(str);
    00115   }
    00116   MsgStream log(msgSvc(), name());
    00117   log << MSG::ERROR << "Cannot output serialize Generator settings!" << endmsg;
    00118   return str;
    00119 }
    00120
    00122 IRndmEngine* RndmGenSvc::engine()     {
    00123   return m_engine;
    00124 }
    00125
    00127 StatusCode RndmGenSvc::generator(const IRndmGen::Param& par, IRndmGen*& refpGen)   {
    00128   StatusCode status = StatusCode::FAILURE;
    00129   IInterface* iface = PluginService::CreateWithId<IInterface*>(par.type(),(IInterface*)m_engine);
    00130   if ( iface ) {
    00131     // query requested interface (adds ref count)
    00132     status = iface->queryInterface(IRndmGen::interfaceID(), (void**)& refpGen);
    00133     if ( status.isSuccess() )   {
    00134       status = refpGen->initialize(par);
    00135     }
    00136     else  {
    00137       iface->release();
    00138     }
    00139   }
    00140   // Error!
    00141   return status;
    00142 }
    00143
    00144 // Single shot returning single random number
    00145 double RndmGenSvc::rndm() const   {
    00146   if ( 0 != m_engine )    {
    00147     return m_engine->rndm();
    00148   }
    00149   return -1;
    00150 }
    00151
    00152 /*  Multiple shots returning vector with flat random numbers.
    00153     @param  array    Array containing random numbers
    00154     @param  howmany  fill 'howmany' random numbers into array
    00155     @param  start    ... starting at position start
    00156     @return StatusCode indicating failure or success.
    00157 */
    00158 StatusCode RndmGenSvc::rndmArray( std::vector<double>& array, long howmany, long start) const   {
    00159   if ( 0 != m_engine )    {
    00160     return m_engine->rndmArray(array, howmany, start);
    00161   }
    00162   return StatusCode::FAILURE;
    00163 }
    00164
    00165 // Allow to set new seeds
    00166 StatusCode RndmGenSvc::setSeeds(const std::vector<long>& seeds)   {
    00167   if ( 0 != m_engine )    {
    00168     return m_engine->setSeeds(seeds);
    00169   }
    00170   return StatusCode::FAILURE;
    00171 }
    00172
    00173 // Allow to get the seeds
    00174 StatusCode RndmGenSvc::seeds(std::vector<long>& seeds)  const  {
    00175   if ( 0 != m_engine )    {
    00176     return m_engine->seeds(seeds);
    00177   }
    00178   return StatusCode::FAILURE;
    00179 }
    00180