---

HepRndmEngines.cpp

Go to the documentation of this file.

//====================================================================
//      Random Engine implementations
//--------------------------------------------------------------------
//
//      Package    : HepRndm ( The LHCb Offline System)
//      Author     : M.Frank
//  History    :
// +---------+----------------------------------------------+---------
// |    Date |                 Comment                      | Who     
// +---------+----------------------------------------------+---------
// | 29/10/99| Initial version                              | MF
// +---------+----------------------------------------------+---------
//
//  Note: Currently all engines require only ONE seed
//        We aill return only the first number, because 
//        the implementation in CLHEP does not allow to
//        determine the proper number of seeds used.
#define NUMBER_OF_SEEDS    1
//
//====================================================================
#define HEPRNDM_HEPRNDMENGINES_CPP

// STL include files
#include <iostream>
#include <cfloat>
#include <ctime>
#include <cmath>

// Framework include files
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/System.h"
#include "GaudiKernel/MsgStream.h"

#include "RndmGenSvc.h"
#include "HepRndmEngine.h"

#include "CLHEP/Random/DualRand.h"
#include "CLHEP/Random/TripleRand.h"
#include "CLHEP/Random/DRand48Engine.h"
#include "CLHEP/Random/Hurd160Engine.h"
#include "CLHEP/Random/Hurd288Engine.h"
#include "CLHEP/Random/JamesRandom.h"
#include "CLHEP/Random/MTwistEngine.h"
#include "CLHEP/Random/RanecuEngine.h"
#include "CLHEP/Random/Ranlux64Engine.h"
#include "CLHEP/Random/RanluxEngine.h"
#include "CLHEP/Random/RanshiEngine.h"

namespace HepRndm  {

  // Standard constructor
  template <class TYPE> Engine<TYPE>::Engine(const std::string& nam, ISvcLocator* loc)
  : BaseEngine (nam, loc)    {
    declareProperty("Seeds",   m_seeds);
    declareProperty("Column",  m_col = 0);
    declareProperty("Row",     m_row = 1);
    declareProperty("Luxury",  m_lux = 3);
    declareProperty("UseTable",m_useTable = false);
  }

  // Standard destructor
  template <class TYPE> Engine<TYPE>::~Engine()          {  
  }

  // Initialize engine
  template <class TYPE> StatusCode Engine<TYPE>::initialize()          {  
    m_seeds.erase(m_seeds.begin(), m_seeds.end());
    StatusCode status = RndmEngine::initialize();
    if ( m_seeds.size() == 0 )  {
      // Default seeds
      long theSeed = 1234567;
      m_seeds.push_back(theSeed);
      m_seeds.push_back(theSeed+1);
    }
    MsgStream log(messageService(), name());
    if ( status.isSuccess() )   {
      status = initializeEngine();
      if ( status.isSuccess() )   {
        log << MSG::INFO << "Generator engine type:" 
                  << System::typeinfoName(typeid(TYPE)) 
                  << endreq;
        if ( m_useTable )   {
          if ( m_row > 214 || m_col > 1 )   {
            log << MSG::ERROR << "Generator engine seed table has dimension [215][2], you gave:"
                << " Row=" << m_row << " Column:" << m_col << endreq;
            status = StatusCode::FAILURE;
          }
          else    {
            log << MSG::INFO << "Generator engine seeds from table."
                << " Row=" << m_row << " Column:" << m_col << endreq;
          }
        }
        log << "Current Seed:" << m_hepEngine->getSeed();
        log << " Luxury:" << m_lux;
        log << endreq;
        return status;
      }
    }
    log << MSG::ERROR << "Cannot initialze random engine of type:" 
          << System::typeinfoName(typeid(TYPE)) 
        << endreq;
    return status;
  }

  // Finalize engine
  template <class TYPE> StatusCode Engine<TYPE>::finalize()          {  
    m_seeds.erase(m_seeds.begin(), m_seeds.end());
    if ( m_hepEngine ) delete m_hepEngine;
    m_hepEngine = 0;
    return RndmEngine::finalize();
  }

  // Retrieve single random number
  template <class TYPE> double Engine<TYPE>::rndm() const  {
    return m_hepEngine->flat();
  }

  // Retrieve seeds
  template <class TYPE> StatusCode Engine<TYPE>::setSeeds(const std::vector<long>& seed)   {  
    for ( size_t i = 0; i < seed.size(); i++ )  {
      if ( m_seeds.size() > i )  
        m_seeds[i] = seed[i];
      else 
        m_seeds.push_back(seed[i]);
    }
    m_hepEngine->setSeeds((long*)&m_seeds[0], m_lux);
    return StatusCode::SUCCESS;
  }

  // Retrieve seeds
  template <class TYPE> StatusCode Engine<TYPE>::seeds(std::vector<long>& seed)  const  {  
    /* 
    const long *s = m_hepEngine->getSeeds();
    for ( size_t i = 0; i < NUMBER_OF_SEEDS; i++ )   {
      seed.push_back(s[i]);
      if ( m_seeds.size() > i )  
        m_seeds[i] = s[i];
      else 
        m_seeds.push_back(s[i]);
    }
    */
    seed.push_back(m_hepEngine->getSeed());
    return StatusCode::SUCCESS;
  }

  // Specialized shoot function for DualRand engine
  template <> StatusCode Engine<DualRand>::initializeEngine()  {
    m_hepEngine = (m_useTable) ? new DualRand(m_row, m_col) : new DualRand(m_seeds[0]);
    return StatusCode::SUCCESS;
  }
  // Specialized shoot function for TripleRand engine
  template <> StatusCode Engine<TripleRand>::initializeEngine()  {
    m_hepEngine = (m_useTable) ? new TripleRand(m_row, m_col) : new TripleRand(m_seeds[0]);
    return StatusCode::SUCCESS;
  }
  // Specialized shoot function for DRand48Engine
  template <> StatusCode Engine<DRand48Engine>::initializeEngine()  {
    m_hepEngine = (m_useTable) ? new DRand48Engine(m_row, m_col) : new DRand48Engine(m_seeds[0]);
    return StatusCode::SUCCESS;
  }
  // Specialized shoot function for Hurd160Engine
  template <> StatusCode Engine<Hurd160Engine>::initializeEngine()  {
    m_hepEngine = (m_useTable) ? new Hurd160Engine(m_row, m_col) : new Hurd160Engine(m_seeds[0]);
    return StatusCode::SUCCESS;
  }
  // Specialized shoot function for Hurd288Engine
  template <> StatusCode Engine<Hurd288Engine>::initializeEngine()  {
    m_hepEngine = (m_useTable) ? new Hurd288Engine(m_row, m_col) : new Hurd288Engine(m_seeds[0]);
    return StatusCode::SUCCESS;
  }
  // Specialized shoot function for RanecuEngine
  template <> StatusCode Engine<RanecuEngine>::initializeEngine()  {
    m_hepEngine = (m_useTable) ? new RanecuEngine(m_row) : new RanecuEngine(m_seeds[0]);
    return StatusCode::SUCCESS;
  }
  // Specialized shoot function for RanshiEngine
  template <> StatusCode Engine<RanshiEngine>::initializeEngine()  {
    m_hepEngine = (m_useTable) ? new RanshiEngine(m_row, m_col) : new RanshiEngine(m_seeds[0]);
    return StatusCode::SUCCESS;
  }
  // Specialized shoot function for RanluxEngine
  template <> StatusCode Engine<RanluxEngine>::initializeEngine()  {
    m_hepEngine = (m_useTable) ? new RanluxEngine(m_row, m_col, m_lux) : new RanluxEngine(m_seeds[0], m_lux);
    return StatusCode::SUCCESS;
  }
  // Specialized shoot function for Ranlux64Engine
  template <> StatusCode Engine<Ranlux64Engine>::initializeEngine()  {
    m_hepEngine = (m_useTable) ? new Ranlux64Engine(m_row, m_col, m_lux) : new Ranlux64Engine(m_seeds[0], m_lux);
    return StatusCode::SUCCESS;
  }
  // Specialized shoot function for MTwistEngine
  template <> StatusCode Engine<MTwistEngine>::initializeEngine()  {
    m_hepEngine = (m_useTable) ? new MTwistEngine(m_row, m_col) : new MTwistEngine(m_seeds[0]);
    return StatusCode::SUCCESS;
  }
  // Specialized shoot function for HepJamesRandom
  template <> StatusCode Engine<HepJamesRandom>::initializeEngine()  {
    m_hepEngine = (m_useTable) ? new HepJamesRandom(m_row, m_col) : new HepJamesRandom(m_seeds[0]);
    return StatusCode::SUCCESS;
  }

};

// Instantiate factories
static SvcFactory< HepRndm::Engine<DualRand> >        s_DualRandEngineFactory;
const ISvcFactory& DualRandEngineFactory =            s_DualRandEngineFactory;

static SvcFactory< HepRndm::Engine<TripleRand> >      s_TripleRandEngineFactory;
const ISvcFactory& TripleRandEngineFactory =          s_TripleRandEngineFactory;

static SvcFactory< HepRndm::Engine<DRand48Engine> >   s_DRand48EngineFactory;
const ISvcFactory& DRand48EngineFactory =             s_DRand48EngineFactory;

static SvcFactory< HepRndm::Engine<Hurd160Engine> >   s_Hurd160EngineFactory;
const ISvcFactory& Hurd160EngineFactory =             s_Hurd160EngineFactory;

static SvcFactory< HepRndm::Engine<Hurd288Engine> >   s_Hurd288EngineFactory;
const ISvcFactory& Hurd288EngineFactory =             s_Hurd288EngineFactory;

static SvcFactory< HepRndm::Engine<HepJamesRandom> >  s_HepJamesRandomFactory;
const ISvcFactory& HepJamesRandomFactory =            s_HepJamesRandomFactory;

static SvcFactory< HepRndm::Engine<MTwistEngine> >    s_MTwistEngineFactory;
const ISvcFactory& MTwistEngineFactory =              s_MTwistEngineFactory;

static SvcFactory< HepRndm::Engine<RanecuEngine> >    s_RanecuEngineFactory;
const ISvcFactory& RanecuEngineFactory =              s_RanecuEngineFactory;

static SvcFactory< HepRndm::Engine<Ranlux64Engine> >  s_Ranlux64EngineFactory;
const ISvcFactory& Ranlux64EngineFactory =            s_Ranlux64EngineFactory;

static SvcFactory< HepRndm::Engine<RanluxEngine> >    s_RanluxEngineFactory;
const ISvcFactory& RanluxEngineFactory =              s_RanluxEngineFactory;

static SvcFactory< HepRndm::Engine<RanshiEngine> >    s_RanshiEngineFactory;
const ISvcFactory& RanshiEngineFactory =              s_RanshiEngineFactory;

---