BesRndmGenSvc Class Reference

#include <BesRndmGenSvc.h>

Inheritance diagram for BesRndmGenSvc:

Public Types
typedef std::map< std::string, CLHEP::RanluxEngine * >	engineMap
	CLHEP engines typedefs:
typedef engineMap::iterator	engineIter
typedef engineMap::const_iterator	engineConstIter
typedef engineMap::value_type	engineValType

Public Member Functions
CLHEP::HepRandomEngine *	GetEngine (const std::string &StreamName)
	Interface to the CLHEP engine.
void	CreateStream (long seed, const std::string &StreamName)
engineConstIter	begin (void) const
engineConstIter	end (void) const
unsigned int	number_of_streams (void) const
void	setGenseed (long i)
long	getGenseed ()
void	print (const std::string &StreamName)
	Print methods.
void	print (void)
CLHEP::HepRandomEngine *	setOnDefinedSeeds (int EventNumber, const std::string &StreamName)
	set the seeds for an engine. First param will usually be the event number
StatusCode	initialize ()
	Gaudi Service Implementation.
StatusCode	finalize ()
void	handle (const Incident &)
	IIncidentListener implementation. Handles EndEvent incident.
	BesRndmGenSvc (const std::string &name, ISvcLocator *svc)
	Standard Constructor.
virtual	~BesRndmGenSvc ()
	Standard Destructor.

Friends
class	SvcFactory< BesRndmGenSvc >

Detailed Description

Definition at line 34 of file BesRndmGenSvc.h.

Member Typedef Documentation

engineConstIter

engineMap::const_iterator BesRndmGenSvc::engineConstIter

Definition at line 49 of file BesRndmGenSvc.h.

engineIter

engineMap::iterator BesRndmGenSvc::engineIter

Definition at line 48 of file BesRndmGenSvc.h.

engineMap

std::map<std::string, CLHEP::RanluxEngine*> BesRndmGenSvc::engineMap

CLHEP engines typedefs:

Definition at line 47 of file BesRndmGenSvc.h.

engineValType

engineMap::value_type BesRndmGenSvc::engineValType

Definition at line 50 of file BesRndmGenSvc.h.

Constructor & Destructor Documentation

BesRndmGenSvc()

BesRndmGenSvc::BesRndmGenSvc	(	const std::string &	name,
		ISvcLocator *	svc )

Standard Constructor.

Definition at line 42 of file BesRndmGenSvc.cxx.

    : 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();
}

~BesRndmGenSvc()

BesRndmGenSvc::~BesRndmGenSvc ( )

virtual

Standard Destructor.

Definition at line 80 of file BesRndmGenSvc.cxx.

{
    delete  m_engines;
}

Member Function Documentation

begin()

BesRndmGenSvc::engineConstIter BesRndmGenSvc::begin ( void ) const

inline

Definition at line 128 of file BesRndmGenSvc.h.

{ return m_engines->begin(); }

Referenced by handle(), and initialize().

CreateStream()

void BesRndmGenSvc::CreateStream	(	long	seed,
		const std::string &	StreamName )

Definition at line 276 of file BesRndmGenSvc.cxx.

{
    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 );
}

Referenced by initialize().

end()

BesRndmGenSvc::engineConstIter BesRndmGenSvc::end ( void ) const

inline

Definition at line 132 of file BesRndmGenSvc.h.

{ return m_engines->end(); }

Referenced by handle(), and initialize().

finalize()

StatusCode BesRndmGenSvc::finalize

(

)

Definition at line 254 of file BesRndmGenSvc.cxx.

{
    MsgStream log(messageService(), name());
    log << MSG::INFO << " FINALISING " << endreq;
    return Service::finalize();
}

GetEngine()

CLHEP::HepRandomEngine * BesRndmGenSvc::GetEngine

(

const std::string &

StreamName

)

Interface to the CLHEP engine.

Definition at line 262 of file BesRndmGenSvc.cxx.

{
    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;
}

Referenced by handle(), and initialize().

getGenseed()

long BesRndmGenSvc::getGenseed ( )

inline

Definition at line 58 of file BesRndmGenSvc.h.

{ return genSeed; }

handle()

void BesRndmGenSvc::handle

(

const Incident &

inc

)

IIncidentListener implementation. Handles EndEvent incident.

Definition at line 209 of file BesRndmGenSvc.cxx.

                                         {
  MsgStream log( messageService(), name() );
  log << MSG::DEBUG << " Handle EndEvent " << endreq;
 
  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 << endreq;
    }
    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();    
  }
}

initialize()

StatusCode BesRndmGenSvc::initialize

(

)

Gaudi Service Implementation.

Incident Service

Definition at line 105 of file BesRndmGenSvc.cxx.

{
  MsgStream log( messageService(), name() );
  log << MSG::INFO << "Initializing " << name()
      << " - package version " << PACKAGE_VERSION 
      << "\n INITIALISING RANDOM NUMBER STREAMS. " << endreq;
 
 
    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 "
      << endreq;
      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 <<endreq;
        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 << endreq;
        CLHEP::HepRandomEngine* engine = GetEngine(stream);
        engine->get(v);
          } else {      
        log << MSG::ERROR << "bad line\n" << buffer 
            << "\n in input file " << m_file_to_read << endreq;
        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 << endreq; 
    } else {
      log << MSG::ERROR << "bad Seeds property\n" << *i << endreq; 
      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 << endreq;
        CreateStream(v[0], stream);
    }
    
    }
    
    return StatusCode::SUCCESS;
}

number_of_streams()

unsigned int BesRndmGenSvc::number_of_streams ( void ) const

inline

Definition at line 136 of file BesRndmGenSvc.h.

{ return m_engines->size(); }

Referenced by initialize().

print() [1/2]

void BesRndmGenSvc::print

(

const std::string &

StreamName

)

Print methods.

Definition at line 330 of file BesRndmGenSvc.cxx.

{
    MsgStream log(messageService(), name());
    engineConstIter citer = m_engines->find(StreamName);
    if ( citer == m_engines->end() )
    {
    log << MSG::WARNING << " Stream =  " << StreamName << " NOT FOUND" << endreq;
    }
    else
    {
    const long s    =   ((*citer).second)->getSeed();
    log << MSG::INFO << " Stream =  " << StreamName << ", Seed =  "
        << s << endreq;
    }
}

print() [2/2]

void BesRndmGenSvc::print

(

void

)

Definition at line 347 of file BesRndmGenSvc.cxx.

{
    print( m_StreamName );
}

Referenced by print().

setGenseed()

void BesRndmGenSvc::setGenseed ( long i )

inline

Definition at line 57 of file BesRndmGenSvc.h.

{ genSeed = i; }

setOnDefinedSeeds()

CLHEP::HepRandomEngine * BesRndmGenSvc::setOnDefinedSeeds	(	int	EventNumber,
		const std::string &	StreamName )

set the seeds for an engine. First param will usually be the event number

Definition at line 353 of file BesRndmGenSvc.cxx.

{
  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);
  long hashedStream;
  // (SG::simpleStringHash(StreamName));
  long theseed = 10000*EventNumber + hashedStream;
  ((*iter).second)->setSeed( theseed, 3 );
  return    (CLHEP::HepRandomEngine*)(*iter).second;
}

Friends And Related Symbol Documentation

SvcFactory< BesRndmGenSvc >

friend class SvcFactory< BesRndmGenSvc >

friend

Definition at line 113 of file BesRndmGenSvc.h.

---

The documentation for this class was generated from the following files:

• BesRndmGenSvc.h
• BesRndmGenSvc.cxx