BesRndmGenSvc.cxx

Go to the documentation of this file.

#include "BesRndmGenSvc.h"
 
// #ifndef HAVE_NEW_IOSTREAMS /*gnu-specific*/
// #define BOOST_NO_STRINGSTREAM 1 /*FIXME should come from boost config */
// #endif
#include <boost/lexical_cast.hpp>
#include <boost/tokenizer.hpp>
#include <iostream>
 
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/Incident.h"
#include "GaudiKernel/MsgStream.h"
using namespace std;
 
DECLARE_COMPONENT( BesRndmGenSvc )
 
bool interpretSeeds( const string& buffer, string& stream, std::vector<unsigned long>& seed ) {
  bool status( false );
  seed.clear();
  // split the space-separated string in 3 words:
  typedef boost::tokenizer<boost::char_separator<char>> tokenizer;
  boost::char_separator<char>                           sep( " " );
  tokenizer                                             tokens( buffer, sep );
  if ( status = ( distance( tokens.begin(), tokens.end() ) == 32 ) )
  {
    tokenizer::iterator token( tokens.begin() );
    stream = *token++;
    try
    {
      for ( int i = 0; i < 31; i++ )
      {
        long tmp = boost::lexical_cast<long>( *token++ );
        seed.push_back( tmp );
      }
    } catch ( boost::bad_lexical_cast e )
    { status = false; }
  }
  return status;
}
 
/// Standard Constructor
BesRndmGenSvc::BesRndmGenSvc( const std::string& name, ISvcLocator* svc )
    : base_class( name, svc ) {
  // Property Default values
  m_read_from_file = false;
  m_file_to_read   = "BesRndmGenSvc.out";
  ofile            = "BesRndmGenSvc.out";
 
  // Set Default values
  m_default_seed         = 11000;
  m_EVTGEN_default_seed  = 35910;
  m_PYTHIA_default_seed  = 93531;
  m_HERWIG_default_seed  = 35391;
  m_LUNDCRM_default_seed = 12456;
  m_SIM_default_seed     = 23569;
  m_MIX_default_seed     = 76543;
  m_KKMC_default_seed    = 26877;
  // Get user's input
  declareProperty( "Seeds", m_streams_seeds );
  declareProperty( "StreamName", m_StreamName = "EVTGEN" );
  declareProperty( "ReadFromFile", m_read_from_file );
  declareProperty( "FileToRead", m_file_to_read );
  declareProperty( "RdmOutFile", ofile );
  declareProperty( "RndmSeed", m_default_seed );
 
  Stream_EVTGEN  = "EVTGEN";
  Stream_PYTHIA  = "PYTHIA";
  Stream_HERWIG  = "HERWIG";
  Stream_LUNDCRM = "LUNDCRM";
  Stream_SIM     = "SIM";
  Stream_MIX     = "MIX";
  Stream_KKMC    = "KKMC";
 
  m_engines = new engineMap();
}
 
/// Standard Destructor
BesRndmGenSvc::~BesRndmGenSvc() { delete m_engines; }
 
// Query the interfaces.
//   Input: riid, Requested interface ID
//          ppvInterface, Pointer to requested interface
//   Return: StatusCode indicating SUCCESS or FAILURE.
// N.B. Don't forget to release the interface after use!!!
/*StatusCode
BesRndmGenSvc::queryInterface(const InterfaceID& riid, void** ppvInterface)
{
    if ( IBesRndmGenSvc::interfaceID().versionMatch(riid) )    {
        *ppvInterface = (IBesRndmGenSvc*)this;
    }
    else  {
    // Interface is not directly available: try out a base class
    return Service::queryInterface(riid, ppvInterface);
    }
    addRef();
    return StatusCode::SUCCESS;
}
*/
StatusCode BesRndmGenSvc::initialize() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "Initializing " << name() << " - package version "
      << "FIXME: PACKAGE_VERSION"
      << "\n INITIALISING RANDOM NUMBER STREAMS. " << endmsg;
 
  if ( !( Service::initialize().isSuccess() ) ) { return StatusCode::FAILURE; }
 
  // set up different stream seeds by default seed
  m_EVTGEN_default_seed  = m_default_seed + 35910;
  m_PYTHIA_default_seed  = m_default_seed + 93531;
  m_HERWIG_default_seed  = m_default_seed + 35391;
  m_LUNDCRM_default_seed = m_default_seed + 12456;
  m_SIM_default_seed     = m_default_seed + 23569;
  m_MIX_default_seed     = m_default_seed + 76543;
  m_KKMC_default_seed    = m_default_seed + 26877;
 
  /// Incident Service
  IIncidentSvc* pIncSvc( 0 );
 
  // set up the incident service:
  if ( !( service( "IncidentSvc", pIncSvc, true ) ).isSuccess() )
  {
    log << MSG::ERROR << "Could not locate IncidentSvc " << endmsg;
    return StatusCode::FAILURE;
  }
 
  // start listening to "EndEvent"
  static const int PRIORITY = 100;
  pIncSvc->addListener( this, "EndEvent", PRIORITY );
 
  if ( m_read_from_file )
  {
    // Read from a file
    ifstream infile( m_file_to_read.c_str() );
    if ( !infile )
    {
      log << MSG::ERROR << " Unable to open: " << m_file_to_read << endmsg;
      return StatusCode::FAILURE;
    }
    else
    {
      std::string buffer;
      while ( std::getline( infile, buffer ) )
      {
        string                     stream;
        std::vector<unsigned long> v;
        // split the space-separated string in 3 words:
        if ( interpretSeeds( buffer, stream, v ) )
        {
          log << MSG::DEBUG << " INITIALISING " << stream << " stream, "
              << " read from file " << m_file_to_read << endmsg;
          CLHEP::HepRandomEngine* engine = GetEngine( stream );
          engine->get( v );
        }
        else
        {
          log << MSG::ERROR << "bad line\n"
              << buffer << "\n in input file " << m_file_to_read << endmsg;
          return StatusCode::FAILURE;
        }
      }
    }
  }
 
  // Create the various streams according to user's request
  for ( VStrings::const_iterator i = m_streams_seeds.begin(); i != m_streams_seeds.end(); ++i )
  {
    string                     stream;
    std::vector<unsigned long> v;
    // split the space-separated string in 3 words:
    if ( interpretSeeds( *i, stream, v ) )
    { log << MSG::VERBOSE << "Seeds property: stream " << stream << endmsg; }
    else
    {
      log << MSG::ERROR << "bad Seeds property\n" << *i << endmsg;
      return StatusCode::FAILURE;
    }
 
    // Check if stream already generated (e.g. from reading a file)
    bool not_found = true;
    if ( number_of_streams() != 0 )
    {
      BesRndmGenSvc::engineConstIter sf = begin();
      do {
        if ( ( *sf ).first == stream ) not_found = false;
        ++sf;
      } while ( sf != end() && not_found );
    }
 
    if ( not_found )
    {
      log << MSG::DEBUG << " INITIALISING " << stream << endmsg;
      CreateStream( v[0], stream );
    }
  }
 
  return StatusCode::SUCCESS;
}
 
void BesRndmGenSvc::handle( const Incident& inc ) {
  MsgStream log( msgSvc(), name() );
  log << MSG::DEBUG << " Handle EndEvent " << endmsg;
 
  if ( inc.type() == "EndEvent" )
  {
 
    m_engines_copy.clear();
    for ( engineConstIter i = begin(); i != end(); ++i )
    {
      CLHEP::HepRandomEngine*    engine = GetEngine( ( *i ).first );
      std::vector<unsigned long> s      = engine->put();
      std::vector<long int>      tseeds;
      for ( unsigned int j = 0; j < s.size(); j++ ) { tseeds.push_back( s[j] ); }
      m_engines_copy.insert(
          std::map<std::string, std::vector<long int>>::value_type( ( *i ).first, tseeds ) );
    }
    // Write the status of the Service into a file
    /*
        ofstream    outfile( ofile.c_str() );
        if ( !outfile )
        {
          log <<MSG::ERROR << "error: unable to open: " << ofile << endmsg;
        }
        else
        {
            for (std::map<std::string, std::vector<long int> >::const_iterator i =
       m_engines_copy.begin(); i != m_engines_copy.end();
                 ++i)
            {
                outfile << (*i).first;
                for(unsigned int j=0; j<((*i).second).size(); j++)
                  outfile << " " << (*i).second[j];
                outfile <<"\n";
            }
        }
    */
    //    print();
  }
}
 
StatusCode BesRndmGenSvc::finalize() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << " FINALISING " << endmsg;
  return Service::finalize();
}
 
CLHEP::HepRandomEngine* BesRndmGenSvc::GetEngine( const std::string& StreamName ) {
  engineConstIter citer = m_engines->find( StreamName );
  if ( citer == m_engines->end() )
  {
    m_engines->insert( engineValType( StreamName, new CLHEP::RanluxEngine() ) );
    SetStreamSeeds( StreamName );
  }
 
  engineIter iter = m_engines->find( StreamName );
  return (CLHEP::HepRandomEngine*)( *iter ).second;
}
 
void BesRndmGenSvc::CreateStream( long seed, const std::string& StreamName ) {
  engineConstIter citer = m_engines->find( StreamName );
  if ( citer == m_engines->end() )
    m_engines->insert( engineValType( StreamName, new CLHEP::RanluxEngine() ) );
  engineIter iter = m_engines->find( StreamName );
  ( ( *iter ).second )->setSeed( seed, 3 );
}
 
void BesRndmGenSvc::SetStreamSeeds( const std::string& StreamName ) {
  long theseed;
  if ( StreamName == "PYTHIA" ) { theseed = m_PYTHIA_default_seed; }
  else if ( StreamName == "HERWIG" ) { theseed = m_HERWIG_default_seed; }
  else if ( StreamName == "EVTGEN" ) { theseed = m_EVTGEN_default_seed; }
  else if ( StreamName == "LUNDCRM" ) { theseed = m_LUNDCRM_default_seed; }
  else if ( StreamName == "SIM" ) { theseed = m_SIM_default_seed; }
  else if ( StreamName == "MIX" ) { theseed = m_MIX_default_seed; }
  else if ( StreamName == "KKMC" ) { theseed = m_KKMC_default_seed; }
  else
  {
    theseed = m_default_seed;
    MsgStream log( msgSvc(), name() );
    log << MSG::WARNING << " INITIALISING " << StreamName << " stream with DEFAULT seed "
        << theseed << endmsg;
  }
 
  engineIter iter = m_engines->find( StreamName );
  ( ( *iter ).second )->setSeed( theseed, 3 );
}
 
void BesRndmGenSvc::print( const std::string& StreamName ) {
  MsgStream       log( msgSvc(), name() );
  engineConstIter citer = m_engines->find( StreamName );
  if ( citer == m_engines->end() )
  { log << MSG::WARNING << " Stream =  " << StreamName << " NOT FOUND" << endmsg; }
  else
  {
    const long s = ( ( *citer ).second )->getSeed();
    log << MSG::INFO << " Stream =  " << StreamName << ", Seed =  " << s << endmsg;
  }
}
 
void BesRndmGenSvc::print( void ) { print( m_StreamName ); }
 
CLHEP::HepRandomEngine* BesRndmGenSvc::setOnDefinedSeeds( int                EventNumber,
                                                          const std::string& StreamName ) {
  engineConstIter citer = m_engines->find( StreamName );
  if ( citer == m_engines->end() )
    m_engines->insert( engineValType( StreamName, new CLHEP::RanluxEngine() ) );
  engineIter iter = m_engines->find( StreamName );
  // (SG::simpleStringHash(StreamName));
  long theseed = 10000 * EventNumber;
  ( ( *iter ).second )->setSeed( theseed, 3 );
  return (CLHEP::HepRandomEngine*)( *iter ).second;
}