---

RndmGenSvc.cpp

Go to the documentation of this file.

//====================================================================
//      Random Generator service implementation
//--------------------------------------------------------------------
//
//      Package    : Gaudi/RndmGen ( The LHCb Offline System)
//      Author     : M.Frank
//  History    :
// +---------+----------------------------------------------+---------
// |    Date |                 Comment                      | Who     
// +---------+----------------------------------------------+---------
// | 29/10/99| Initial version                              | MF
// +---------+----------------------------------------------+---------
//
//====================================================================
#define GAUDI_RANDOMGENSVC_RNDMGENSVC_CPP

// STL include files
#include <cfloat>

// Framework include files
#include "GaudiKernel/SmartIF.h"
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/IObjManager.h"
#include "GaudiKernel/ISvcManager.h"
#include "GaudiKernel/IRndmEngine.h"
#include "GaudiKernel/IRndmGenFactory.h"

#include "GaudiKernel/MsgStream.h"

#include "RndmGen.h"
#include "RndmGenSvc.h"

// Instantiation of a static factory class used by clients to create
// instances of this service
static const SvcFactory<RndmGenSvc> s_factory;
const ISvcFactory& RndmGenSvcFactory = s_factory;

RndmGenSvc::RndmGenSvc(const std::string& nam, ISvcLocator* svc)
: Service(nam, svc), m_engine(0), m_serialize(0)
{
  declareProperty("Engine", m_engineName = "HepRndm::Engine<RanluxEngine>");
}

RndmGenSvc::~RndmGenSvc()   {
}

StatusCode RndmGenSvc::queryInterface(const IID& riid, void** ppvInterface)  {
  if ( IID_IRndmGenSvc == riid )   {
    *ppvInterface = (IRndmGenSvc*)this;
  }
  else if ( IID_IRndmEngine == riid )   {
    *ppvInterface = (IRndmEngine*)this;
  }
  else if ( IID_ISerialize == riid )   {
    *ppvInterface = (ISerialize*)this;
  }
  else  {
    return Service::queryInterface(riid, ppvInterface);
  }
  addRef();
  return StatusCode::SUCCESS;
}

StatusCode RndmGenSvc::initialize()   {
  StatusCode status = Service::initialize();
  MsgStream log(msgSvc(), name());
  std::string machName = name()+".Engine";
  SmartIF<IRndmEngine> engine(IID_IRndmEngine);
  SmartIF<ISvcManager> mgr(IID_ISvcManager, serviceLocator());

  if ( status.isSuccess() )   {
    status = setProperties();
    if ( status.isSuccess() )   {  // Check if the Engine service exists:
      status = serviceLocator()->getService(machName, IID_IRndmEngine, (IInterface*&)engine.pRef());
      if ( !status.isSuccess() && mgr.isValid( ) )   {
        IService* service = 0;
        // Engine does not exist: We have to create one!
        status = mgr->createService(m_engineName,machName,service);
        engine = service;
      }
      if ( status.isSuccess() )   {
        SmartIF<ISerialize> serial(IID_ISerialize, engine);
        SmartIF<IService>   service(IID_IService,  engine);
        if ( serial.isValid( ) && service.isValid( ) )  {
          status = service->initialize();
          if ( status.isSuccess() )   {
            m_engine = engine;
            m_serialize = serial;
            m_engine->addRef();
            m_serialize->addRef();
            log << MSG::INFO << "Using Random engine:" << m_engineName << endreq;
            return status;
          }
        }
      }
    }
  }
  return status;
}

StatusCode RndmGenSvc::finalize()   {
  StatusCode status = Service::finalize();
  for ( FactoryContainer::iterator i = m_factories.begin(); i != m_factories.end(); i++ ) {
    (*i)->release();
  }
  m_factories.erase(m_factories.begin(), m_factories.end());
  if ( m_serialize ) m_serialize->release();
  m_serialize = 0;
  if ( m_engine )  m_engine->release();
  m_engine = 0;
  return status;
}


StreamBuffer& RndmGenSvc::serialize(StreamBuffer& str)    {
  if ( 0 != m_serialize )    {
    return m_serialize->serialize(str);
  }
  MsgStream log(msgSvc(), name());
  log << MSG::ERROR << "Cannot input serialize Generator settings!" << endreq;
  return str;
}

StreamBuffer& RndmGenSvc::serialize(StreamBuffer& str) const    {
  if ( 0 != m_serialize )    {
    return m_serialize->serialize(str);
  }
  MsgStream log(msgSvc(), name());
  log << MSG::ERROR << "Cannot output serialize Generator settings!" << endreq;
  return str;
}

IRndmEngine* RndmGenSvc::engine()     {
  return m_engine;
}

StatusCode RndmGenSvc::addFactory(const IRndmGenFactory* fac)    {
  if ( 0 != fac )  {
    for ( FactoryContainer::iterator i = m_factories.begin(); i != m_factories.end(); i++ ) {
      if ( (*i)->type() == fac->type() )   {
        (*i)->release();
        (*i) = fac;
        return StatusCode::SUCCESS;
      }
    }
    m_factories.push_back(fac);
    return StatusCode::SUCCESS;
  }
  return StatusCode::FAILURE;
}

StatusCode RndmGenSvc::removeFactory(const IID& type)   {
  for ( FactoryContainer::iterator i = m_factories.begin(); i != m_factories.end(); i++ ) {
    if ( (*i)->type() == type )   {
      m_factories.erase(i);
      return StatusCode::SUCCESS;
    }
  }
  return StatusCode::FAILURE;
}

StatusCode RndmGenSvc::generator(const IRndmGen::Param& par, IRndmGen*& refpGen)   {
  StatusCode status = StatusCode::FAILURE;
  const IRndmGenFactory* fac = factory(par.type());
  // If the factory is not present, ask for it.... 
  if ( 0 == fac )   {
    status = requestFactory( par.type(), fac);
    if ( status.isSuccess() )   {
      // Add factory now: for the next time.
      status = addFactory( fac );
      if ( status.isSuccess() )   {
        // Factory found and added: now create generator
        return createGenerator(fac, par, refpGen);
      }
    }
    // Error!
    return status;
  }
  // Factory found: create generator
  return createGenerator(fac, par, refpGen);
}

// Check the list of known factories for the requested type
const IRndmGenFactory* RndmGenSvc::factory(const IID& type)   {
  for ( FactoryContainer::iterator i = m_factories.begin(); i != m_factories.end(); i++ ) {
    if ( (*i)->type() == type )   {
      return *i;
    }
  }
  return 0;
}

// Request a new factory from the object manager
StatusCode RndmGenSvc::requestFactory(const IID& type, const IRndmGenFactory*& refpFactory)    {
  IObjManager* objManager = 0;
  StatusCode status = serviceLocator()->queryInterface(IID_IObjManager, (void**)&objManager);
  refpFactory = 0;
  if ( status.isSuccess() )   {
    StatusCode iret;
    IObjManager::ObjIterator i, stop;
    const IRndmGenFactory* fac;
    for ( i = objManager->objBegin(), stop = objManager->objEnd(); i != stop; i++ )    {
      IFactory* f = const_cast<IFactory*>(*i);
      iret = f->queryInterface(IID_IRndmGenFactory, (void**)&fac);
      if ( iret.isSuccess() )   {
        if ( fac->type() == type )    {
          refpFactory = fac;
          return StatusCode::SUCCESS;
        }
        fac->release();   // Unused interface must be released
      }
    }
    objManager->release(); // Must release interface after use!
  }
  return StatusCode::FAILURE;
}

// Create new Generator from known factory
StatusCode RndmGenSvc::createGenerator(const IRndmGenFactory* pFactory, const IRndmGen::Param& par, IRndmGen*& refpGen)    {
  StatusCode status = StatusCode::FAILURE;
  refpGen = 0;
  if ( 0 != pFactory )    {
    IInterface *iface = pFactory->instantiate(m_engine);
    if ( iface )    {
      // query requested interface (adds ref count)
      status = iface->queryInterface(IID_IRndmGen, (void**)& refpGen);
      if ( status.isSuccess() )   {
        status = refpGen->initialize(par);
      }
      else  {
        iface->release();
      }
    }
  }
  return status;
}

// Single shot returning single random number
double RndmGenSvc::rndm() const   {
  if ( 0 != m_engine )    {
    return m_engine->rndm();
  }
  return -1;
}

/*  Multiple shots returning vector with flat random numbers.
    @param  array    Array containing random numbers 
    @param  howmany  fill 'howmany' random numbers into array
    @param  start    ... starting at position start
    @return StatusCode indicating failure or success.
*/
StatusCode RndmGenSvc::rndmArray( std::vector<double>& array, long howmany, long start) const   {
  if ( 0 != m_engine )    {
    return m_engine->rndmArray(array, howmany, start);
  }
  return StatusCode::FAILURE;
}

// Allow to set new seeds
StatusCode RndmGenSvc::setSeeds(const std::vector<long>& seeds)   {
  if ( 0 != m_engine )    {
    return m_engine->setSeeds(seeds);
  }
  return StatusCode::FAILURE;
}

// Allow to get the seeds
StatusCode RndmGenSvc::seeds(std::vector<long>& seeds)  const  {
  if ( 0 != m_engine )    {
    return m_engine->seeds(seeds);
  }
  return StatusCode::FAILURE;
}

---