A random number engine manager, based on Ranecu. Its usage is deprecated, at least when high quality sequences of randoms are required (Ranecu period has been shown to be too short, and sensitive to the quality of initial seeds). More...

#include <AtRndmGenSvc.h>

Inheritance diagram for AtRndmGenSvc:

Collaboration diagram for AtRndmGenSvc:

Public Member Functions
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

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 More...

CLHEP::HepRandomEngine *	oldSetOnDefinedSeeds (uint32_t eventNumber, uint32_t runNumber, const std::string &streamName)
	broken, temporarily keep for backward compatibility More...

virtual bool	setAllOnDefinedSeeds (uint32_t theSeed) override
	seed all streams we manage, combining theSeed and the stream names More...

virtual bool	setAllOnDefinedSeeds (uint32_t eventNumber, uint32_t runNumber) override
	seed all streams, combining eventNumber, runNumber and the stream names More...

Gaudi Service Implementation
virtual StatusCode	initialize () override

virtual StatusCode	finalize () override

virtual void	handle (const Incident &) override
	IIncidentListener implementation. Handles EndEvent incident. More...

Private Attributes
Properties
Gaudi::Property< bool >	m_useOldBrokenSeeding {this,"UseOldBrokenSeeding",false}
	backward compatibility only, broken 32/64 bits More...

StringArrayProperty	m_streams_seeds

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

Gaudi::Property< std::string >	m_file_to_read
	name of the file to read the engine status from More...

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 ? More...

Gaudi::Property< std::string >	m_file_to_write
	name of the file to save the engine status to. More...

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

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 More...

std::map< std::string, uint32_t >	m_reseedingOffsets
	optional offsets to combine to run/evt no when reseeding. More...

engineMap	m_engines

std::map< std::string, std::vector< long int > >	m_engines_copy
	Random engine copy (for output to a file) More...

Interface to the CLHEP engine
typedef std::map< std::string, CLHEP::RanecuEngine * >	engineMap
	CLHEP engines typedefs: More...

typedef engineMap::iterator	engineIter

typedef engineMap::const_iterator	engineConstIter

typedef engineMap::value_type	engineValType

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

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

Default seed values
long	m_default_seed1

long	m_default_seed2

long	m_PYTHIA_default_seed1

long	m_PYTHIA_default_seed2

long	m_HERWIG_default_seed1

long	m_HERWIG_default_seed2

	AtRndmGenSvc (const std::string &name, ISvcLocator *svc)
	Standard Constructor. More...

virtual	~AtRndmGenSvc ()
	Standard Destructor. More...

void	SetStreamSeeds (const std::string &streamName)

Detailed Description

A random number engine manager, based on Ranecu. Its usage is deprecated, at least when high quality sequences of randoms are required (Ranecu period has been shown to be too short, and sensitive to the quality of initial seeds).

this service mantains a number of named, independent random number sequences. Each sequence is initialized by an entry of the form "SequenceName Seed1 Seed2" in the Seeds property. For example

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

At the end of the job in AtRndmGenSvc::finalize(), the status of the engine is dumped as an array of unsigned long to the ASCII file "AtRndmGenSvc.out". 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 56 of file AtRndmGenSvc.h.

Member Typedef Documentation

◆ engineConstIter

typedef engineMap::const_iterator AtRndmGenSvc::engineConstIter

Definition at line 69 of file AtRndmGenSvc.h.

◆ engineIter

typedef engineMap::iterator AtRndmGenSvc::engineIter

Definition at line 68 of file AtRndmGenSvc.h.

◆ engineMap

typedef std::map<std::string, CLHEP::RanecuEngine*> AtRndmGenSvc::engineMap

CLHEP engines typedefs:

Definition at line 67 of file AtRndmGenSvc.h.

◆ engineValType

typedef engineMap::value_type AtRndmGenSvc::engineValType

Definition at line 70 of file AtRndmGenSvc.h.

Constructor & Destructor Documentation

◆ AtRndmGenSvc()

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

Standard Constructor.

Definition at line 27 of file AtRndmGenSvc.cxx.

   : base_class(name,svc),
     m_reseedingOffsets(),
     m_engines(), m_engines_copy()
 {
     // 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;
 }

◆ ~AtRndmGenSvc()

AtRndmGenSvc::~AtRndmGenSvc ( )

virtual

Standard Destructor.

Definition at line 43 of file AtRndmGenSvc.cxx.

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

Member Function Documentation

◆ begin()

AtRndmGenSvc::engineConstIter AtRndmGenSvc::begin ( void ) const

inline

Definition at line 165 of file AtRndmGenSvc.h.

166 { return m_engines.begin(); }

◆ CreateStream()

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

overridevirtual

Definition at line 268 of file AtRndmGenSvc.cxx.

 {
     engineConstIter citer = m_engines.find(streamName);
     if (citer == m_engines.end())
       m_engines.insert(engineValType(streamName, new CLHEP::RanecuEngine()));
     engineIter iter = m_engines.find(streamName);
     long seeds[3] = { (long)seed1, (long) seed2, 0 };
     ((*iter).second)->setSeeds( seeds, -1 );
 }

◆ end()

AtRndmGenSvc::engineConstIter AtRndmGenSvc::end ( void ) const

inline

Definition at line 169 of file AtRndmGenSvc.h.

170 { return m_engines.end(); }

◆ finalize()

StatusCode AtRndmGenSvc::finalize ( )

overridevirtual

Definition at line 232 of file AtRndmGenSvc.cxx.

 {
   ATH_MSG_INFO (" FINALISING ");
  
   if (m_save_to_file) {
     // Write the status of the Service into a 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<long int> >::const_iterator i = m_engines_copy.begin();
         i != m_engines_copy.end();
         ++i) { 
     outfile << (*i).first << " " << (*i).second[0] << " " << (*i).second[1] << "\n";
       }
       ATH_MSG_DEBUG (" wrote seeds to " << m_file_to_write.value() );
     }
   }
   return StatusCode::SUCCESS;
 }

◆ GetEngine()

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

overridevirtual

Definition at line 254 of file AtRndmGenSvc.cxx.

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

◆ handle()

void AtRndmGenSvc::handle ( const Incident & inc )

overridevirtual

IIncidentListener implementation. Handles EndEvent incident.

Definition at line 150 of file AtRndmGenSvc.cxx.

                                         {
  
   if ( inc.type() == "EndEvent" ||
        inc.type() == "AfterReseedIncident" ) 
   {
     ATH_MSG_DEBUG (" Handle EndEvent ");
     m_engines_copy.clear();
     for (engineConstIter i = begin(); i != end(); ++i)
     {
       CLHEP::HepRandomEngine* engine = GetEngine((*i).first);
       const long*       s = engine->getSeeds();
       std::vector<long int> tseeds;
       tseeds.push_back(s[0]);
       tseeds.push_back(s[1]);
       m_engines_copy.insert( 
     std::map<std::string, std::vector<long int> >::value_type( (*i).first,
                                            tseeds ) );
     }
     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);
     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 AtRndmGenSvc::initialize ( )

overridevirtual

Incident Service

Definition at line 51 of file AtRndmGenSvc.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");
       pIncSvc->addListener(this, "ReseedIncident", PRIORITY);
   }
   pIncSvc.release().ignore();
  
   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; 
       uint32_t seed1, seed2;
       if (interpretSeeds(buffer, stream, seed1, seed2)) {
         ATH_MSG_DEBUG 
           (" INITIALISING " << stream << " stream with seeds "
            << seed1 << "  " << seed2 
            << " read from file " << m_file_to_read.value());
         CreateStream(seed1, seed2, stream);
       } else {      
         ATH_MSG_ERROR
           ("bad line\n" << buffer 
            << "\n in input file " << m_file_to_read.value());
         return StatusCode::FAILURE;
       }     
     }
     
       }
     }
  
     // Create the various streams according to user's request
   for (const auto& i : m_streams_seeds.value()) {
       string stream; 
       uint32_t seed1, seed2, offset(0);
       short dummy;
       if (interpretSeeds(i, stream, seed1, seed2, dummy, offset)) {
     ATH_MSG_VERBOSE
       ("Seeds property: stream " << stream 
        << " seeds " << seed1 << ' ' << seed2
        << ", 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 ) {
     AtRndmGenSvc::engineConstIter sf        =   begin();
     do {
       if ((*sf).first == stream) not_found = false;
       ++sf;
     } while (sf != end() && not_found);
       }
     
       if (not_found) {
     ATH_MSG_DEBUG
       (" INITIALISING " << stream << " stream with seeds "
        << seed1 << "  " << seed2);
     CreateStream(seed1, seed2, stream);
     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 AtRndmGenSvc::number_of_streams ( void ) const

inline

Definition at line 173 of file AtRndmGenSvc.h.

174 { return m_engines.size(); }

◆ oldSetOnDefinedSeeds() [1/2]

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

broken, temporarily keep for backward compatibility

Definition at line 374 of file AtRndmGenSvc.cxx.

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

◆ oldSetOnDefinedSeeds() [2/2]

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

broken, temporarily keep for backward compatibility

Definition at line 392 of file AtRndmGenSvc.cxx.

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

◆ print() [1/2]

virtual void AtRndmGenSvc::print ( const std::string & streamName )

overridevirtual

◆ print() [2/2]

virtual void AtRndmGenSvc::print ( void )

overridevirtual

◆ setAllOnDefinedSeeds() [1/2]

virtual bool AtRndmGenSvc::setAllOnDefinedSeeds	(	uint32_t	eventNumber,
		uint32_t	runNumber
	)

overridevirtual

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

◆ setAllOnDefinedSeeds() [2/2]

virtual bool AtRndmGenSvc::setAllOnDefinedSeeds ( uint32_t theSeed )

overridevirtual

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

◆ setOnDefinedSeeds() [1/2]

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

overridevirtual

◆ setOnDefinedSeeds() [2/2]

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

overridevirtual

◆ SetStreamSeeds()

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

private

Definition at line 280 of file AtRndmGenSvc.cxx.

 {
     long seed1;
     long 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);
     
     long seeds[3] = { seed1, seed2, 0 };
     const long* s = seeds;
     engineIter  iter    =   m_engines.find(streamName);
     ((*iter).second)->setSeeds( s, -1 );
 }

Member Data Documentation

◆ m_default_seed1

long AtRndmGenSvc::m_default_seed1

private

Definition at line 144 of file AtRndmGenSvc.h.

◆ m_default_seed2

long AtRndmGenSvc::m_default_seed2

private

Definition at line 145 of file AtRndmGenSvc.h.

◆ m_engines

engineMap AtRndmGenSvc::m_engines

private

Definition at line 137 of file AtRndmGenSvc.h.

◆ m_engines_copy

std::map<std::string, std::vector<long int> > AtRndmGenSvc::m_engines_copy

private

Random engine copy (for output to a file)

Definition at line 139 of file AtRndmGenSvc.h.

◆ m_eventReseed

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

private

reseed for every event

Definition at line 128 of file AtRndmGenSvc.h.

◆ m_file_to_read

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

private

Initial value:

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

name of the file to read the engine status from

Definition at line 120 of file AtRndmGenSvc.h.

◆ m_file_to_write

Gaudi::Property<std::string> AtRndmGenSvc::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 125 of file AtRndmGenSvc.h.

◆ m_HERWIG_default_seed1

long AtRndmGenSvc::m_HERWIG_default_seed1

private

Definition at line 148 of file AtRndmGenSvc.h.

◆ m_HERWIG_default_seed2

long AtRndmGenSvc::m_HERWIG_default_seed2

private

Definition at line 149 of file AtRndmGenSvc.h.

◆ m_PYTHIA_default_seed1

long AtRndmGenSvc::m_PYTHIA_default_seed1

private

Definition at line 146 of file AtRndmGenSvc.h.

◆ m_PYTHIA_default_seed2

long AtRndmGenSvc::m_PYTHIA_default_seed2

private

Definition at line 147 of file AtRndmGenSvc.h.

◆ m_read_from_file

Gaudi::Property<bool> AtRndmGenSvc::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 119 of file AtRndmGenSvc.h.

◆ m_reseedingOffsets

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

private

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

Set using OFFSET keyword of the Seeds property

Definition at line 135 of file AtRndmGenSvc.h.

◆ m_reseedStreamNames

StringArrayProperty AtRndmGenSvc::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 129 of file AtRndmGenSvc.h.

◆ m_save_to_file

Gaudi::Property<bool> AtRndmGenSvc::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 124 of file AtRndmGenSvc.h.

◆ m_streams_seeds

StringArrayProperty AtRndmGenSvc::m_streams_seeds

private

Initial value:

{this,"Seeds",{},
    "seeds for the engines, this is a vector of strings of the form ['SequenceName [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>"}

Definition at line 112 of file AtRndmGenSvc.h.

◆ m_useOldBrokenSeeding

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

private

backward compatibility only, broken 32/64 bits

Definition at line 111 of file AtRndmGenSvc.h.

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

Public Member Functions

Private Attributes

Interface to the CLHEP engine

Default seed values

Detailed Description

Member Typedef Documentation

◆ engineConstIter

◆ engineIter

◆ engineMap

◆ engineValType

Constructor & Destructor Documentation

◆ AtRndmGenSvc()

◆ ~AtRndmGenSvc()

Member Function Documentation

◆ begin()

◆ CreateStream()

◆ end()

◆ finalize()

◆ GetEngine()

◆ handle()

◆ initialize()

◆ number_of_streams()

◆ oldSetOnDefinedSeeds() [1/2]

◆ oldSetOnDefinedSeeds() [2/2]

◆ print() [1/2]

◆ print() [2/2]

◆ setAllOnDefinedSeeds() [1/2]

◆ setAllOnDefinedSeeds() [2/2]

◆ setOnDefinedSeeds() [1/2]

◆ setOnDefinedSeeds() [2/2]

◆ SetStreamSeeds()

Member Data Documentation

◆ m_default_seed1

◆ m_default_seed2

◆ m_engines

◆ m_engines_copy

◆ m_eventReseed

◆ m_file_to_read

◆ m_file_to_write

◆ m_HERWIG_default_seed1

◆ m_HERWIG_default_seed2

◆ m_PYTHIA_default_seed1

◆ m_PYTHIA_default_seed2

◆ m_read_from_file

◆ m_reseedingOffsets

◆ m_reseedStreamNames

◆ m_save_to_file

◆ m_streams_seeds

◆ m_useOldBrokenSeeding