AtRndmGenSvc Class Reference

A random number engine manager, based on Ranecu. 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
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
Gaudi::Property< bool >	m_useOldBrokenSeeding {this,"UseOldBrokenSeeding",false}
	backward compatibility only, broken 32/64 bits
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
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
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< long int > >	m_engines_copy
	Random engine copy (for output to a file)

Interface to the CLHEP engine
typedef std::map< std::string, CLHEP::RanecuEngine * >	engineMap
	CLHEP engines typedefs:
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.
virtual	~AtRndmGenSvc ()
	Standard Destructor.
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.

{ return m_engines.begin(); }

CreateStream()

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

overridevirtual

Definition at line 272 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.

{ return m_engines.end(); }

finalize()

StatusCode AtRndmGenSvc::finalize ( )

overridevirtual

Definition at line 236 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 258 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);
    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 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.

{ 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 378 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 396 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]

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

overridevirtual

Definition at line 314 of file AtRndmGenSvc.cxx.

{
    engineConstIter citer = m_engines.find(streamName);
    if ( citer == m_engines.end() )
    {
      ATH_MSG_WARNING (" Stream =  " << streamName << " NOT FOUND");
    }
    else
    {
    const long* s  =   ((*citer).second)->getSeeds();
    ATH_MSG_INFO (" Stream =  " << streamName << ", Seed1 =  "
              << s[0] << ", Seed2 = " << s[1]);
    }
}

print() [2/2]

void AtRndmGenSvc::print ( void )

overridevirtual

Definition at line 330 of file AtRndmGenSvc.cxx.

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

setAllOnDefinedSeeds() [1/2]

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

overridevirtual

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

Definition at line 412 of file AtRndmGenSvc.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 AtRndmGenSvc::setAllOnDefinedSeeds ( uint32_t theSeed )

overridevirtual

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

Definition at line 426 of file AtRndmGenSvc.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 * AtRndmGenSvc::setOnDefinedSeeds ( uint32_t eventNumber, uint32_t runNumber, const std::string & streamName )

overridevirtual

Definition at line 337 of file AtRndmGenSvc.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 * AtRndmGenSvc::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 357 of file AtRndmGenSvc.cxx.

                                            {
  if (m_useOldBrokenSeeding) 
    return oldSetOnDefinedSeeds(theSeed, streamName);
  //do it properly
  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);
  theSeed=crc_combine(theSeed, streamName);
  ATH_MSG_DEBUG("Reseeding stream " << streamName << " with " << theSeed);
  //Ranecu 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 Ranecu as a 32 bit
  //signed int
  ((*iter).second)->setSeed( (int32_t)theSeed, 0);
  return (CLHEP::HepRandomEngine*)(*iter).second;
}

SetStreamSeeds()

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

private

Definition at line 284 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.

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

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.

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

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.

                                              {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

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.

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

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.

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

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.

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

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.

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

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.

{this,"UseOldBrokenSeeding",false}; 

---

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

• AtRndmGenSvc.h
• AtRndmGenSvc.cxx