AtRanluxGenSvc Class Reference

The default ATLAS random number engine manager, based on Ranlux64. More...

#include <AtRanluxGenSvc.h>

Inheritance diagram for AtRanluxGenSvc:

Collaboration diagram for AtRanluxGenSvc:

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

Public Member Functions
Interface to the CLHEP engine
virtual CLHEP::HepRandomEngine *	GetEngine (const std::string &streamName) override
virtual void	CreateStream (uint32_t seed1, uint32_t seed2, const std::string &streamName) override
bool	CreateStream (const std::vector< uint32_t > &seeds, const std::string &streamName)
Stream access
engineConstIter	begin (void) const
engineConstIter	end (void) const
unsigned int	number_of_streams (void) const
virtual void	print (const std::string &streamName) override
virtual void	print (void) override
void	createStream (uint32_t seed1, uint32_t seed2, const std::string &streamName, short luxLevel)
	allows to specify luxLevel
virtual CLHEP::HepRandomEngine *	setOnDefinedSeeds (uint32_t theSeed, const std::string &streamName) override
virtual CLHEP::HepRandomEngine *	setOnDefinedSeeds (uint32_t eventNumber, uint32_t runNumber, const std::string &streamName) override
CLHEP::HepRandomEngine *	oldSetOnDefinedSeeds (uint32_t theSeed, const std::string &streamName)
	broken, temporarily keep for backward compatibility
CLHEP::HepRandomEngine *	oldSetOnDefinedSeeds (uint32_t eventNumber, uint32_t runNumber, const std::string &streamName)
	broken, temporarily keep for backward compatibility
virtual bool	setAllOnDefinedSeeds (uint32_t theSeed) override
	seed all streams we manage, combining theSeed and the stream names
virtual bool	setAllOnDefinedSeeds (uint32_t eventNumber, uint32_t runNumber) override
	seed all streams, combining eventNumber, runNumber and the stream names
Gaudi Service Implementation
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual void	handle (const Incident &) override
	IIncidentListener implementation. Handles EndEvent incident.

Private Attributes
Properties
StringArrayProperty	m_streams_seeds
	seeds for the engines, this is a vector of strings of the form "EnginName Seed1 Seed2"
Gaudi::Property< bool >	m_read_from_file {this,"ReadFromFile",false,"set/restore the status of the engine from file"}
	read engine status from file
Gaudi::Property< std::string >	m_file_to_read
	name of the file to read the engine status from
Gaudi::Property< bool >	m_save_to_file {this,"SaveToFile", true,"save the status of the engine to file"}
	should current engine status be saved to file ?
Gaudi::Property< std::string >	m_file_to_write
	name of the file to save the engine status to.
Gaudi::Property< bool >	m_eventReseed {this,"EventReseeding",true,"reseed every event using a hash of run and event numbers"}
	reseed for every event
StringArrayProperty	m_reseedStreamNames {this,"ReseedStreamNames",{}, "the streams we are going to set the seeds of (default: all streams)"}
	streams to be reseeded for every event
Gaudi::Property< bool >	m_useOldBrokenSeeding {this,"UseOldBrokenSeeding",false}
	backward compatibility only, broken 32/64 bits
std::map< std::string, uint32_t >	m_reseedingOffsets
	optional offsets to combine to run/evt no when reseeding.
engineMap	m_engines
std::map< std::string, std::vector< uint32_t > >	m_engines_copy
	Random engine copy (for output to a file)
short	m_defaultLuxLevel
	Ranlux luxury level to be used by default.

Default seed values
uint32_t	m_default_seed1
uint32_t	m_default_seed2
uint32_t	m_PYTHIA_default_seed1
uint32_t	m_PYTHIA_default_seed2
uint32_t	m_HERWIG_default_seed1
uint32_t	m_HERWIG_default_seed2
	AtRanluxGenSvc (const std::string &name, ISvcLocator *svc)
	Standard Gaudi Constructor.
virtual	~AtRanluxGenSvc ()
	Standard Destructor.
void	SetStreamSeeds (const std::string &streamName)

Detailed Description

The default ATLAS random number engine manager, based on Ranlux64.

this service mantains a number of named, independent random number sequences. Each sequence is initialized by an entry of the form "SequenceName [LUXURY luxLevel (range 0:2 default 1) ] Seed1 Seed2" in the Seeds property. For example

Seeds = [ "PYTHIA LUXURY 2 4789899 989240512", 
          "PYTHIA_INIT LUXURY 0 820021 2347532",
          "JIMMY 390020611 821000366", 
          "JIMMY_INIT LUXURY 0 820021 2347532",
          "HERWIG 390020611 821000366", "HERWIG_INIT 820021 2347532" ]

At the end of the job in AtRanluxGenSvc::finalize(), the status of the engine is dumped as an array of uint32_t to the ASCII file "AtRanluxGenSvc.out":

PITHIA 4010409557 1071463497 2862960128 1068652744 145815808 1072305199 2363435712 1072215177 2274024032 1071848040 1607052768 1070928280 1688486400 1071840599 2068481888 1067315347 62450688 1072023539 312153120 1070857822 2535009472 1070427845 3698875904 1070616419 3726185024 0 0 11 1 202 
PITHIA_INIT 4010409557 1057836705 3838836736 1072443439 2098440704 1066892778 3689119744 1072151794 3818888768 1071853913 3574320864 1071982408 3603063712 1071718264 2168786016 1072391676 2208235040 1072000044 3037871232 1072480358 3292613248 1071901297 579757952 1065720911 3788918784 0 0 11 1 202 

This file can be used to restore the status of the engine in another job by setting the properties

ReadFromFile = true
FileToRead = path_to_ascii_file

Definition at line 54 of file AtRanluxGenSvc.h.

Member Typedef Documentation

engineConstIter

typedef engineMap::const_iterator AtRanluxGenSvc::engineConstIter

Definition at line 70 of file AtRanluxGenSvc.h.

engineIter

typedef engineMap::iterator AtRanluxGenSvc::engineIter

Definition at line 69 of file AtRanluxGenSvc.h.

engineMap

typedef std::map<std::string, CLHEP::Ranlux64Engine*> AtRanluxGenSvc::engineMap

Definition at line 68 of file AtRanluxGenSvc.h.

engineValType

typedef engineMap::value_type AtRanluxGenSvc::engineValType

Definition at line 71 of file AtRanluxGenSvc.h.

Constructor & Destructor Documentation

AtRanluxGenSvc()

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

Standard Gaudi Constructor.

Standard Constructor.

Definition at line 29 of file AtRanluxGenSvc.cxx.

  : base_class(name,svc),
    m_reseedingOffsets(),
    m_engines(), m_engines_copy(),
    m_defaultLuxLevel(1) 
{
  // Set Default values
    m_default_seed1      =   3591;
    m_default_seed2      =   2309736;
    m_PYTHIA_default_seed1    =   93453591;
    m_PYTHIA_default_seed2    =   73436;
    m_HERWIG_default_seed1    =   355391;
    m_HERWIG_default_seed2    =   97336;
}

~AtRanluxGenSvc()

AtRanluxGenSvc::~AtRanluxGenSvc ( )

virtual

Standard Destructor.

Definition at line 46 of file AtRanluxGenSvc.cxx.

{
  engineIter i(m_engines.begin()), e(m_engines.end());
  while (i != e) delete (i++)->second;
}

Member Function Documentation

begin()

AtRanluxGenSvc::engineConstIter AtRanluxGenSvc::begin ( void ) const

inline

Definition at line 173 of file AtRanluxGenSvc.h.

{ return m_engines.begin(); }

CreateStream() [1/2]

bool AtRanluxGenSvc::CreateStream	(	const std::vector< uint32_t > &	seeds,
		const std::string &	streamName )

Definition at line 326 of file AtRanluxGenSvc.cxx.

{
    engineConstIter citer = m_engines.find(streamName);
    if ( citer == m_engines.end() ) 
      m_engines.insert(engineValType(streamName, 
                     new CLHEP::Ranlux64Engine() ) );
    engineIter    iter = m_engines.find(streamName);
    std::vector<unsigned long> longSeeds(seeds.size());
    for (size_t i=0; i<seeds.size(); ++i) longSeeds[i]=seeds[i];
    return (((*iter).second)->getState( longSeeds ));
}

CreateStream() [2/2]

void AtRanluxGenSvc::CreateStream ( uint32_t seed1, uint32_t seed2, const std::string & streamName )

overridevirtual

Definition at line 306 of file AtRanluxGenSvc.cxx.

                                              {
  createStream(seed1, seed2, streamName, m_defaultLuxLevel);
}

createStream()

void AtRanluxGenSvc::createStream	(	uint32_t	seed1,
		uint32_t	seed2,
		const std::string &	streamName,
		short	luxLevel )

allows to specify luxLevel

Definition at line 312 of file AtRanluxGenSvc.cxx.

{
    uint32_t seeds[2] = { seed1, seed2 };
    const uint32_t* s = seeds;
    engineConstIter citer = m_engines.find(streamName);
    if ( citer == m_engines.end() ) 
      m_engines.insert(engineValType(streamName, 
                     new CLHEP::Ranlux64Engine(s[0], luxLevel)));
    engineIter iter = m_engines.find(streamName);
    ((*iter).second)->setSeed(s[0], luxLevel);
}

end()

AtRanluxGenSvc::engineConstIter AtRanluxGenSvc::end ( void ) const

inline

Definition at line 177 of file AtRanluxGenSvc.h.

{ return m_engines.end(); }

finalize()

StatusCode AtRanluxGenSvc::finalize ( )

overridevirtual

Definition at line 265 of file AtRanluxGenSvc.cxx.

{
  ATH_MSG_INFO (" FINALISING ");
 
  if (m_save_to_file) {
    // Write the status of the Service to file
    std::ofstream outfile( m_file_to_write.value().c_str() );
    if ( !outfile ) {
      ATH_MSG_ERROR ("error: unable to open: " << m_file_to_write.value());
    } else {
      for (std::map<std::string, std::vector<uint32_t> >::const_iterator i = m_engines_copy.begin();
       i != m_engines_copy.end();
       ++i) {
    outfile << (*i).first << " ";
    for (std::vector<uint32_t>::const_iterator j = (*i).second.begin(); j !=(*i).second.end(); ++j){
      outfile << (*j) << " ";
    }
    outfile << endl;
      }
      ATH_MSG_DEBUG (" wrote seeds to " << m_file_to_write.value() );
      
    }
  }
  return StatusCode::SUCCESS;
}

GetEngine()

CLHEP::HepRandomEngine * AtRanluxGenSvc::GetEngine ( const std::string & streamName )

overridevirtual

Definition at line 292 of file AtRanluxGenSvc.cxx.

{
    engineConstIter citer = m_engines.find(StreamName);
    if ( citer == m_engines.end() )
    {
    m_engines.insert( engineValType( StreamName, new CLHEP::Ranlux64Engine() ) );
    SetStreamSeeds    ( StreamName );
    }
    
    engineIter    iter    =   m_engines.find(StreamName);
    return  (CLHEP::HepRandomEngine*)(*iter).second;
}

handle()

void AtRanluxGenSvc::handle ( const Incident & inc )

overridevirtual

IIncidentListener implementation. Handles EndEvent incident.

Definition at line 170 of file AtRanluxGenSvc.cxx.

                                          {
  ATH_MSG_DEBUG (" Handle EndEvent ");
 
  if ( inc.type() == "EndEvent" ||
       inc.type() == "AfterReseedIncident" ) 
  {
 
    m_engines_copy.clear();
    engineConstIter iE(begin()), eE(end());
    while(iE != eE) {
      CLHEP::HepRandomEngine* engine = GetEngine(iE->first);
      std::vector<unsigned long> v = engine->put();
      std::vector<uint32_t> tseeds(v.size());
      for (size_t i=0; i<v.size(); ++i) {
        // The state returned is a set of 32-bit numbers.
        // On 64-bit platforms, though, the vector holds 64-bit ints.
        // For the first word, one gets garbage in the high 32 bits.
        // (This is because the crc32 routine used in clhep
        // to hash the engine names doesn't mask down to 32 bits.)
        // Mask off the garbage to get consistent results
        // across platforms.
    tseeds[i] = (v[i] & 0xffffffffu);
      }
      m_engines_copy.insert(std::make_pair(iE->first, tseeds));
      ++iE;
    }
    
    print();    
  } else if (inc.type() == "BeginEvent") {
    ATH_MSG_DEBUG (" Handle BeginEvent ");
    EventContext context = inc.context();
    const EventIDBase& ei = context.eventID();
    //clear static RandGauss cache (generates two numbers per call to shoot()
    CLHEP::RandGauss::setFlag(false);
    //loop over generator streams, combining the stream name to the hash
    vector<string>::const_iterator i(m_reseedStreamNames.begin());
    vector<string>::const_iterator e(m_reseedStreamNames.end());
    //by default (when no streams are specified in streamNames, seed all
    //streams
    if (i == e) {
      if (!(this->setAllOnDefinedSeeds(ei.event_number(), 
                       ei.run_number())))
    throw GaudiException("can not reseed all streams ", name(), StatusCode::FAILURE);
    } else {
      while (i != e) {
    const string& strName(*i++);
    if (0 == this->setOnDefinedSeeds(ei.event_number(), 
                     ei.run_number(),
                     strName)) { 
      throw GaudiException(string("can not reseed stream ") + strName,  
                   name(), StatusCode::FAILURE);
    } else {
      msg() << MSG::VERBOSE << "Reseeded stream " << strName 
        << " for random service " << endmsg;
    }
      }
    }
  }
  else if (inc.type() == "ReseedIncident") {
    typedef ContextIncident<std::pair<unsigned,unsigned> > Ctxt;
    const Ctxt* incident = dynamic_cast<const Ctxt*>(&inc);
    if (!incident) {
      throw GaudiException(string("can not cast to ContextIncident "),
                           name(), StatusCode::FAILURE);
    }
    const std::pair<unsigned,unsigned>& data = incident->tag();
    //clear static RandGauss cache (generates two numbers per call to shoot()
    CLHEP::RandGauss::setFlag(false);
    //loop over generator streams, combining the stream name to the hash
    vector<string>::const_iterator i(m_reseedStreamNames.begin());
    vector<string>::const_iterator e(m_reseedStreamNames.end());
    //by default (when no streams are specified in streamNames, seed all
    //streams
    if (i == e) {
      if (!(this->setAllOnDefinedSeeds(data.first,
                                       data.second)))
        throw GaudiException("can not reseed all streams ", name(), StatusCode::FAILURE);
    } else {
      while (i != e) {
        const string& strName(*i++);
        if (0 == this->setOnDefinedSeeds(data.first,
                                         data.second,
                                         strName)) {
          throw GaudiException(string("can not reseed stream ") + strName,
                               name(), StatusCode::FAILURE);
        } else {
          msg() << MSG::VERBOSE << "Reseeded stream " << strName
                << " for random service " << endmsg;
        }
      }
    }
  }
}

initialize()

StatusCode AtRanluxGenSvc::initialize ( )

overridevirtual

Incident Service

Definition at line 54 of file AtRanluxGenSvc.cxx.

{
  ATH_MSG_INFO
    ("Initializing " << name()
     << "\n INITIALISING RANDOM NUMBER STREAMS. ");

  ServiceHandle<IIncidentSvc> pIncSvc("IncidentSvc", name());
 
  // set up the incident service:
  ATH_CHECK( pIncSvc.retrieve() );
 
  //start listening to "EndEvent"
  static const int PRIORITY = 100;
  pIncSvc->addListener(this, "EndEvent", PRIORITY);
  pIncSvc->addListener(this, "AfterReseedIncident", PRIORITY);
 
  //and to BeginEvent if we are reseeding
  if (m_eventReseed) {
      ATH_MSG_INFO ("will be reseeded for every event");
      pIncSvc->addListener(this, "BeginEvent", PRIORITY);
      pIncSvc->addListener(this, "ReseedIncident", PRIORITY);
  }
  pIncSvc.release().ignore();
 
 
  //3 is not valid for ranlux, but whatever, that's what we had before...
  if (m_useOldBrokenSeeding) m_defaultLuxLevel = 3; 
 
  if (m_read_from_file) {
    // Read from a file
    ifstream    infile( m_file_to_read.value().c_str() );
    if ( !infile ) {
      ATH_MSG_ERROR (" Unable to open: " << m_file_to_read.value());
      return StatusCode::FAILURE;
    } else {
      std::string buffer;
      while (std::getline(infile, buffer)) {
    string stream; 
    std::vector<uint32_t> seeds;
    //split the space-separated string in 3 words:
    if (interpretSeeds(buffer, stream, seeds)) {
      msg (MSG::DEBUG) 
        << " INITIALISING " << stream << " stream with seeds ";
      for (std::vector<uint32_t>::const_iterator i = seeds.begin(); i != seeds.end(); ++i){
            // The state returned is a set of 32-bit numbers.
            // On 64-bit platforms, though, the vector holds 64-bit ints.
            // For the first word, one gets garbage in the high 32 bits.
            // (This is because the crc32 routine used in clhep
            // to hash the engine names doesn't mask down to 32 bits.)
            // So mask off the garbage so that we get consistent results
            // across platforms.
            msg() << ((*i) & 0xffffffffu) << " ";
      }
      msg() << " read from file " << m_file_to_read.value() << endmsg;
      if (CreateStream(seeds, stream)) {
        msg(MSG::DEBUG)
          << stream << " stream initialized succesfully" <<endmsg;
      } else {
        msg(MSG::ERROR)
          << stream << " stream FAILED to initialize" <<endmsg;
        return StatusCode::FAILURE;
      }
    } else {        
      msg(MSG::ERROR)
        << "bad line\n" << buffer 
        << "\n in input file " << m_file_to_read.value() << 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) {
  for (const auto& i : m_streams_seeds) {
    string stream; 
    uint32_t seed1, seed2, offset(0);
    //parse the stream property string
    short ll(m_defaultLuxLevel); // temp copy so we don't overwrite default
    if (interpretSeeds(i, stream, seed1, seed2, ll, offset)) {
      ATH_MSG_VERBOSE("Seeds property: stream " << stream 
              << " seeds " << seed1 << ' ' << seed2 
              << ", luxury level " << ll
              << ", reseeding offset " << offset);
    } else {
      ATH_MSG_ERROR("bad Seeds property\n" << i);
      return StatusCode::FAILURE;
    }       
        
    // Check if stream already generated (e.g. from reading a file)
    bool not_found(true);
    if ( number_of_streams() != 0 ) {
      AtRanluxGenSvc::engineConstIter sf(begin());
      while (sf != end() && (not_found=((*sf).first != stream))) ++sf;
    }
    
    if (not_found) {
      ATH_MSG_DEBUG
    (" INITIALISING " << stream << " stream with seeds "
     << seed1 << "  " << seed2);
      createStream(seed1, seed2, stream, ll);
      if (m_eventReseed) {
    m_reseedingOffsets.insert(std::make_pair(stream, offset));
    // apply the offset we just inserted
    ATH_MSG_DEBUG("Applying reseeding  offset " << offset << 
              " to stream " << stream);
    this->setOnDefinedSeeds(seed1, seed2, stream);
      }
    }
    
  }
  return StatusCode::SUCCESS;
}

number_of_streams()

unsigned int AtRanluxGenSvc::number_of_streams ( void ) const

inline

Definition at line 181 of file AtRanluxGenSvc.h.

{ return m_engines.size(); }

oldSetOnDefinedSeeds() [1/2]

CLHEP::HepRandomEngine * AtRanluxGenSvc::oldSetOnDefinedSeeds	(	uint32_t	eventNumber,
		uint32_t	runNumber,
		const std::string &	streamName )

broken, temporarily keep for backward compatibility

Definition at line 444 of file AtRanluxGenSvc.cxx.

{
  engineConstIter citer = m_engines.find(streamName); 
  if ( citer == m_engines.end() ) 
    m_engines.insert( engineValType(streamName, new CLHEP::Ranlux64Engine() ) ); 
  engineIter iter = m_engines.find(streamName); 
  int hashedStream(SG::simpleStringHash(streamName)); 
  long seeds[2] = { (long)(1000*runNumber + hashedStream),
            (long)eventNumber }; 
  assert( seeds[0] > 0 ); 
  assert( seeds[1] > 0 ); 
  const long* s = seeds; 
  ((*iter).second)->setSeed( s[0], m_defaultLuxLevel); 
  return  (CLHEP::HepRandomEngine*)(*iter).second;   
}

oldSetOnDefinedSeeds() [2/2]

CLHEP::HepRandomEngine * AtRanluxGenSvc::oldSetOnDefinedSeeds	(	uint32_t	theSeed,
		const std::string &	streamName )

broken, temporarily keep for backward compatibility

Definition at line 462 of file AtRanluxGenSvc.cxx.

                                                 {
  engineConstIter citer = m_engines.find(streamName); 
  if ( citer == m_engines.end() ) 
    m_engines.insert( engineValType(streamName, new CLHEP::Ranlux64Engine() ) ); 
  engineIter iter =  m_engines.find(streamName); 
  int hashedStream(SG::simpleStringHash(streamName)); 
  long seeds[2] = { (long)(hashedStream % (theSeed+13)), 
            (long)theSeed }; 
  assert( seeds[0] > 0 ); 
  assert( seeds[1] > 0 ); 
  const long* s = seeds; 
  ((*iter).second)->setSeed( s[0], m_defaultLuxLevel ); 
  return        (CLHEP::HepRandomEngine*)(*iter).second; 
}

print() [1/2]

void AtRanluxGenSvc::print ( const std::string & streamName )

overridevirtual

Definition at line 370 of file AtRanluxGenSvc.cxx.

{
    engineConstIter citer = m_engines.find(StreamName);
    if ( citer == m_engines.end() ) {
      ATH_MSG_WARNING (" Stream =  " << StreamName << " NOT FOUND");
    } else {
      std::vector<unsigned long> v = ((*citer).second)->put();
      msg(MSG::INFO) << " Stream =  " << StreamName << " ";
      for (std::vector<unsigned long>::const_iterator i = v.begin(); i != v.end(); ++i){
        // The state returned is a set of 32-bit numbers.
        // On 64-bit platforms, though, the vector holds 64-bit ints.
        // For the first word, one gets garbage in the high 32 bits.
        // (This is because the crc32 routine used in clhep
        // to hash the engine names doesn't mask down to 32 bits.)
        // So mask off the garbage so that we get consistent results
        // across platforms.
    msg() << ((*i) & 0xffffffffu) << " ";
      }
      msg() << endmsg;
    }
}

print() [2/2]

void AtRanluxGenSvc::print ( void )

overridevirtual

Definition at line 393 of file AtRanluxGenSvc.cxx.

{
    for (engineConstIter i = m_engines.begin(); i != m_engines.end(); ++i)
    print( (*i).first );
}

setAllOnDefinedSeeds() [1/2]

bool AtRanluxGenSvc::setAllOnDefinedSeeds ( uint32_t eventNumber, uint32_t runNumber )

overridevirtual

seed all streams, combining eventNumber, runNumber and the stream names

Definition at line 480 of file AtRanluxGenSvc.cxx.

{
  bool allOK(true);
  engineIter i(m_engines.begin()), e(m_engines.end());
  while (i!=e && 
         (allOK=(0 != this->setOnDefinedSeeds(eventNumber,
                                              runNumber,
                                              (*i++).first)))) {
    /*empty*/
  }
  return allOK;
}

setAllOnDefinedSeeds() [2/2]

bool AtRanluxGenSvc::setAllOnDefinedSeeds ( uint32_t theSeed )

overridevirtual

seed all streams we manage, combining theSeed and the stream names

Definition at line 494 of file AtRanluxGenSvc.cxx.

                                                    {
  bool allOK(true);
  engineIter i(m_engines.begin()), e(m_engines.end());
  while (i!=e && 
         (allOK=(0 != this->setOnDefinedSeeds(theSeed, (*i++).first)))) {
    /*empty*/
    }
  return allOK;
}

setOnDefinedSeeds() [1/2]

CLHEP::HepRandomEngine * AtRanluxGenSvc::setOnDefinedSeeds ( uint32_t eventNumber, uint32_t runNumber, const std::string & streamName )

overridevirtual

Definition at line 400 of file AtRanluxGenSvc.cxx.

{
  if (m_useOldBrokenSeeding) 
    return oldSetOnDefinedSeeds(eventNumber, runNumber, streamName);
  // do it properly
  uint32_t theHash(eventNumber);
  map<string, uint32_t>::const_iterator citer(m_reseedingOffsets.find(streamName));
  bool hasOffset(citer != m_reseedingOffsets.end() && 0 != citer->second);
  if (hasOffset) theHash=crc_combine(theHash, citer->second);
 
  theHash=crc_combine(theHash, runNumber);
  ATH_MSG_VERBOSE( "Reseeding stream " << streamName 
           << " with eventNumber " << eventNumber 
           << " runNumber " << runNumber);
  if (hasOffset) ATH_MSG_VERBOSE("Applied offset " <<  citer->second);
  return this->setOnDefinedSeeds(theHash, streamName);
}

setOnDefinedSeeds() [2/2]

CLHEP::HepRandomEngine * AtRanluxGenSvc::setOnDefinedSeeds ( uint32_t theSeed, const std::string & streamName )

overridevirtual

create engine if not found. FIXME this may not be a good idea

Definition at line 420 of file AtRanluxGenSvc.cxx.

                                              {
  if (m_useOldBrokenSeeding) 
    return oldSetOnDefinedSeeds(theSeed, streamName);
  //do it propertly
  engineConstIter citer = m_engines.find(streamName);
  if ( citer == m_engines.end() ) 
    m_engines.insert(engineValType(streamName, 
                   new CLHEP::Ranlux64Engine() ) );
 
  engineIter iter = m_engines.find(streamName);
  theSeed=crc_combine(theSeed, streamName);
  ATH_MSG_DEBUG("Reseeding stream " << streamName << " with " << theSeed);
  CLHEP::Ranlux64Engine* eng = (*iter).second;
  //Ranlux64 takes a long as seed and makes a test on the sign of the seed
  //so let's make sure that our seed is presented to Ranlux64 as a 32 bit
  //signed int
  eng->setSeed( (int32_t)theSeed, eng->getLuxury() );
  return eng;
}

SetStreamSeeds()

void AtRanluxGenSvc::SetStreamSeeds ( const std::string & streamName )

private

Definition at line 340 of file AtRanluxGenSvc.cxx.

{
    uint32_t seed1;
    uint32_t seed2;
    if (StreamName == "PYTHIA")
    {
    seed1 = m_PYTHIA_default_seed1;
    seed2 = m_PYTHIA_default_seed2;
    }
    else if (StreamName == "HERWIG")
    {
    seed1 = m_HERWIG_default_seed1;
    seed2 = m_HERWIG_default_seed2;
    }
    else
    {
    seed1 = m_default_seed1;
    seed2 = m_default_seed2;
    }
    ATH_MSG_WARNING
      (" INITIALISING " << StreamName << " stream with DEFAULT seeds "
       << seed1 << "  " << seed2);
    
    uint32_t seeds[2] = { seed1, seed2 };
    const uint32_t* s = seeds;
    engineIter iter = m_engines.find(StreamName);
    ((*iter).second)->setSeed(s[0]); //FIXME no need to set luxLevel?
}

Member Data Documentation

m_default_seed1

uint32_t AtRanluxGenSvc::m_default_seed1

private

Definition at line 153 of file AtRanluxGenSvc.h.

m_default_seed2

uint32_t AtRanluxGenSvc::m_default_seed2

private

Definition at line 154 of file AtRanluxGenSvc.h.

m_defaultLuxLevel

short AtRanluxGenSvc::m_defaultLuxLevel

private

Ranlux luxury level to be used by default.

Definition at line 148 of file AtRanluxGenSvc.h.

m_engines

engineMap AtRanluxGenSvc::m_engines

private

Definition at line 145 of file AtRanluxGenSvc.h.

m_engines_copy

std::map<std::string, std::vector<uint32_t> > AtRanluxGenSvc::m_engines_copy

private

Random engine copy (for output to a file)

Definition at line 147 of file AtRanluxGenSvc.h.

m_eventReseed

Gaudi::Property<bool> AtRanluxGenSvc::m_eventReseed {this,"EventReseeding",true,"reseed every event using a hash of run and event numbers"}

private

reseed for every event

Definition at line 134 of file AtRanluxGenSvc.h.

{this,"EventReseeding",true,"reseed every event using a hash of run and event numbers"}; 

m_file_to_read

Gaudi::Property<std::string> AtRanluxGenSvc::m_file_to_read

private

Initial value:

{this,"FileToRead",this->name()+".out",
    "name of a ASCII file, usually produced by AtRanLuxGenSvc itself at the end of a job, " 
    "containing the information to fully set/restore the status of Ranlux64"
    }

name of the file to read the engine status from

Definition at line 126 of file AtRanluxGenSvc.h.

                                            {this,"FileToRead",this->name()+".out",
    "name of a ASCII file, usually produced by AtRanLuxGenSvc itself at the end of a job, " \
    "containing the information to fully set/restore the status of Ranlux64"
    }; 

m_file_to_write

Gaudi::Property<std::string> AtRanluxGenSvc::m_file_to_write

private

Initial value:

{this,"FileToWrite",this->name()+".out",
    "name of an ASCII file which will be produced on finalize, containing the information to fully set/restore the status"}

name of the file to save the engine status to.

Definition at line 131 of file AtRanluxGenSvc.h.

                                            {this,"FileToWrite",this->name()+".out",
    "name of an ASCII file which will be produced on finalize, containing the information to fully set/restore the status"}; 

m_HERWIG_default_seed1

uint32_t AtRanluxGenSvc::m_HERWIG_default_seed1

private

Definition at line 157 of file AtRanluxGenSvc.h.

m_HERWIG_default_seed2

uint32_t AtRanluxGenSvc::m_HERWIG_default_seed2

private

Definition at line 158 of file AtRanluxGenSvc.h.

m_PYTHIA_default_seed1

uint32_t AtRanluxGenSvc::m_PYTHIA_default_seed1

private

Definition at line 155 of file AtRanluxGenSvc.h.

m_PYTHIA_default_seed2

uint32_t AtRanluxGenSvc::m_PYTHIA_default_seed2

private

Definition at line 156 of file AtRanluxGenSvc.h.

m_read_from_file

Gaudi::Property<bool> AtRanluxGenSvc::m_read_from_file {this,"ReadFromFile",false,"set/restore the status of the engine from file"}

private

read engine status from file

Definition at line 125 of file AtRanluxGenSvc.h.

{this,"ReadFromFile",false,"set/restore the status of the engine from file"};  

m_reseedingOffsets

std::map<std::string, uint32_t> AtRanluxGenSvc::m_reseedingOffsets

private

optional offsets to combine to run/evt no when reseeding.

Set using OFFSET keyword of the Seeds property

Definition at line 143 of file AtRanluxGenSvc.h.

m_reseedStreamNames

StringArrayProperty AtRanluxGenSvc::m_reseedStreamNames {this,"ReseedStreamNames",{}, "the streams we are going to set the seeds of (default: all streams)"}

private

streams to be reseeded for every event

Definition at line 135 of file AtRanluxGenSvc.h.

{this,"ReseedStreamNames",{}, "the streams we are going to set the seeds of (default: all streams)"};

m_save_to_file

Gaudi::Property<bool> AtRanluxGenSvc::m_save_to_file {this,"SaveToFile", true,"save the status of the engine to file"}

private

should current engine status be saved to file ?

Definition at line 130 of file AtRanluxGenSvc.h.

{this,"SaveToFile", true,"save the status of the engine to file"}; 

m_streams_seeds

StringArrayProperty AtRanluxGenSvc::m_streams_seeds

private

Initial value:

{this,"Seeds",{},
    "seeds for the engines, a string of the form ['SequenceName [LUXURY luxLevel (range 0:2 default 1)()] " 
      "[OFFSET num] Seed1 Seed2', ...] where OFFSET is an optional integer that allows to change the " 
      "sequence of randoms for a given run/event no and SequenceName combination. Notice that " 
      "Seed1/Seed2 are dummy when EventReseeding is used",
      "OrderedSet<std::string>"}

seeds for the engines, this is a vector of strings of the form "EnginName Seed1 Seed2"

Definition at line 117 of file AtRanluxGenSvc.h.

                                       {this,"Seeds",{},
    "seeds for the engines, a string of the form ['SequenceName [LUXURY luxLevel (range 0:2 default 1)()] " \
      "[OFFSET num] Seed1 Seed2', ...] where OFFSET is an optional integer that allows to change the " \
      "sequence of randoms for a given run/event no and SequenceName combination. Notice that " \
      "Seed1/Seed2 are dummy when EventReseeding is used",
      "OrderedSet<std::string>"};

m_useOldBrokenSeeding

Gaudi::Property<bool> AtRanluxGenSvc::m_useOldBrokenSeeding {this,"UseOldBrokenSeeding",false}

private

backward compatibility only, broken 32/64 bits

Definition at line 138 of file AtRanluxGenSvc.h.

{this,"UseOldBrokenSeeding",false}; 

---

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

• AtRanluxGenSvc.h
• AtRanluxGenSvc.cxx