AtDSFMTGenSvc Class Reference

A random number engine manager, based on dSFMT. More...

#include <AtDSFMTGenSvc.h>

Inheritance diagram for AtDSFMTGenSvc:

Collaboration diagram for AtDSFMTGenSvc:

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
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
StringArrayProperty	m_streams_seeds
	seeds for the engines, this is a vector of strings of the form "EnginName Seed1 Seed2" More...
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< uint32_t > >	m_engines_copy
	Random engine copy (for output to a file) More...

Interface to the CLHEP engine
typedef std::map< std::string, CLHEP::HepRandomEngine * >	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
bool	CreateStream (const std::vector< uint32_t > &seeds, const std::string &streamName)

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
	AtDSFMTGenSvc (const std::string &name, ISvcLocator *svc)
	Standard Constructor. More...
virtual	~AtDSFMTGenSvc ()
	Standard Destructor. More...
void	SetStreamSeeds (const std::string &StreamName)

Detailed Description

A random number engine manager, based on dSFMT.

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 AtDSFMTGenSvc::finalize(), the status of the engine is dumped as an array of unsigned long to the ASCII file "AtDSFMTGenSvc.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 51 of file AtDSFMTGenSvc.h.

Member Typedef Documentation

engineConstIter

typedef engineMap::const_iterator AtDSFMTGenSvc::engineConstIter

Definition at line 64 of file AtDSFMTGenSvc.h.

engineIter

typedef engineMap::iterator AtDSFMTGenSvc::engineIter

Definition at line 63 of file AtDSFMTGenSvc.h.

engineMap

typedef std::map<std::string, CLHEP::HepRandomEngine*> AtDSFMTGenSvc::engineMap

CLHEP engines typedefs:

Definition at line 62 of file AtDSFMTGenSvc.h.

engineValType

typedef engineMap::value_type AtDSFMTGenSvc::engineValType

Definition at line 65 of file AtDSFMTGenSvc.h.

Constructor & Destructor Documentation

AtDSFMTGenSvc()

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

Standard Constructor.

Definition at line 27 of file AtDSFMTGenSvc.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;
}

~AtDSFMTGenSvc()

AtDSFMTGenSvc::~AtDSFMTGenSvc ( )

virtual

Standard Destructor.

Definition at line 42 of file AtDSFMTGenSvc.cxx.

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

Member Function Documentation

begin()

AtDSFMTGenSvc::engineConstIter AtDSFMTGenSvc::begin ( void  ) const

inline

Definition at line 149 of file AtDSFMTGenSvc.h.

{ return m_engines.begin(); }

CreateStream() [1/2]

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

Definition at line 293 of file AtDSFMTGenSvc.cxx.

{
    engineConstIter citer = m_engines.find(streamName);
    if ( citer == m_engines.end() ) m_engines.insert(engineValType(streamName, new CLHEP::dSFMTEngine() ) );
    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 AtDSFMTGenSvc::CreateStream ( uint32_t  seed1, uint32_t  seed2, const std::string &  streamName  )

overridevirtual

Definition at line 282 of file AtDSFMTGenSvc.cxx.

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

end()

AtDSFMTGenSvc::engineConstIter AtDSFMTGenSvc::end ( void  ) const

inline

Definition at line 153 of file AtDSFMTGenSvc.h.

{ return m_engines.end(); }

finalize()

StatusCode AtDSFMTGenSvc::finalize ( )

overridevirtual

Definition at line 244 of file AtDSFMTGenSvc.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 * AtDSFMTGenSvc::GetEngine ( const std::string &  streamName )

overridevirtual

Definition at line 269 of file AtDSFMTGenSvc.cxx.

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

handle()

void AtDSFMTGenSvc::handle ( const Incident &  inc )

overridevirtual

IIncidentListener implementation. Handles EndEvent incident.

Definition at line 155 of file AtDSFMTGenSvc.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);
    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 AtDSFMTGenSvc::initialize ( )

overridevirtual

Incident Service

Definition at line 48 of file AtDSFMTGenSvc.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();
 
  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 (const auto& i : m_streams_seeds.value()) {
    string stream; 
    uint32_t seed1, seed2, offset(0);
    //parse the stream property string
    if (interpretSeeds(i, stream, seed1, seed2, 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 ) {
      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);
      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 AtDSFMTGenSvc::number_of_streams ( void  ) const

inline

Definition at line 157 of file AtDSFMTGenSvc.h.

{ return m_engines.size(); }

print() [1/2]

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

overridevirtual

Definition at line 332 of file AtDSFMTGenSvc.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::DEBUG) << " 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 AtDSFMTGenSvc::print ( void  )

overridevirtual

Definition at line 354 of file AtDSFMTGenSvc.cxx.

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

setAllOnDefinedSeeds() [1/2]

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

overridevirtual

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

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

overridevirtual

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

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

overridevirtual

Definition at line 360 of file AtDSFMTGenSvc.cxx.

{
  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 * AtDSFMTGenSvc::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 376 of file AtDSFMTGenSvc.cxx.

                                                                              {
  engineConstIter citer = m_engines.find(streamName);
  if ( citer == m_engines.end() ) 
    m_engines.insert(engineValType(streamName, new CLHEP::dSFMTEngine() ) );
 
  engineIter iter = m_engines.find(streamName);
  theSeed=crc_combine(theSeed, streamName);
  ATH_MSG_DEBUG("Reseeding stream " << streamName << " with " << theSeed);
  CLHEP::HepRandomEngine* eng = (*iter).second;
  eng->setSeed( theSeed, 0 );
  return (CLHEP::HepRandomEngine*)eng;
}

SetStreamSeeds()

void AtDSFMTGenSvc::SetStreamSeeds ( const std::string &  StreamName )

private

Definition at line 303 of file AtDSFMTGenSvc.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);
    
    long seeds[3] = { (long)seed1, (long)seed2, 0 };
    const long* s = seeds;
    engineIter iter = m_engines.find(StreamName);
    ((*iter).second)->setSeeds(s,0);
}

Member Data Documentation

m_default_seed1

long AtDSFMTGenSvc::m_default_seed1

private

Definition at line 128 of file AtDSFMTGenSvc.h.

m_default_seed2

long AtDSFMTGenSvc::m_default_seed2

private

Definition at line 129 of file AtDSFMTGenSvc.h.

m_engines

engineMap AtDSFMTGenSvc::m_engines

private

Definition at line 121 of file AtDSFMTGenSvc.h.

m_engines_copy

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

private

Random engine copy (for output to a file)

Definition at line 123 of file AtDSFMTGenSvc.h.

m_eventReseed

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

private

reseed for every event

Definition at line 112 of file AtDSFMTGenSvc.h.

m_file_to_read

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

private

Initial value:

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

name of the file to read the engine status from

Definition at line 105 of file AtDSFMTGenSvc.h.

m_file_to_write

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

m_HERWIG_default_seed1

long AtDSFMTGenSvc::m_HERWIG_default_seed1

private

Definition at line 132 of file AtDSFMTGenSvc.h.

m_HERWIG_default_seed2

long AtDSFMTGenSvc::m_HERWIG_default_seed2

private

Definition at line 133 of file AtDSFMTGenSvc.h.

m_PYTHIA_default_seed1

long AtDSFMTGenSvc::m_PYTHIA_default_seed1

private

Definition at line 130 of file AtDSFMTGenSvc.h.

m_PYTHIA_default_seed2

long AtDSFMTGenSvc::m_PYTHIA_default_seed2

private

Definition at line 131 of file AtDSFMTGenSvc.h.

m_read_from_file

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

m_reseedingOffsets

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

private

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

Set using OFFSET keyword of the Seeds property

Definition at line 119 of file AtDSFMTGenSvc.h.

m_reseedStreamNames

StringArrayProperty AtDSFMTGenSvc::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 113 of file AtDSFMTGenSvc.h.

m_save_to_file

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

m_streams_seeds

StringArrayProperty AtDSFMTGenSvc::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>"}

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

Definition at line 95 of file AtDSFMTGenSvc.h.

---

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

• AtDSFMTGenSvc.h
• AtDSFMTGenSvc.cxx