#include <RandomNumberGeneratorService.h>

Inheritance diagram for edm::service::RandomNumberGeneratorService:

Classes
class	LabelAndEngine

class	ModuleIDToEngine

class	SeedsAndName

Public Member Functions
std::unique_ptr< CLHEP::HepRandomEngine >	cloneEngine (LuminosityBlockIndex const &) override

void	consumes (ConsumesCollector &&iC) const override

CLHEP::HepRandomEngine &	getEngine (StreamID const &streamID) override
	Use this engine in event methods. More...

CLHEP::HepRandomEngine &	getEngine (LuminosityBlockIndex const &luminosityBlockIndex) override
	Use this engine in the global begin luminosity block method. More...

std::vector< RandomEngineState > const &	getEventCache (StreamID const &) const override

std::vector< RandomEngineState > const &	getLumiCache (LuminosityBlockIndex const &) const override
	These two are used by the RandomEngineStateProducer. More...

std::uint32_t	mySeed () const override

void	postEventRead (Event const &event) override

void	postModuleBeginStream (StreamContext const &sc, ModuleCallingContext const &mcc)

void	postModuleEndStream (StreamContext const &sc, ModuleCallingContext const &mcc)

void	postModuleStreamBeginLumi (StreamContext const &sc, ModuleCallingContext const &mcc)

void	postModuleStreamBeginRun (StreamContext const &sc, ModuleCallingContext const &mcc)

void	postModuleStreamEndLumi (StreamContext const &sc, ModuleCallingContext const &mcc)

void	postModuleStreamEndRun (StreamContext const &sc, ModuleCallingContext const &mcc)

void	preallocate (SystemBounds const &)

void	preBeginLumi (LuminosityBlock const &lumi) override

void	preModuleBeginStream (StreamContext const &sc, ModuleCallingContext const &mcc)

void	preModuleConstruction (ModuleDescription const &description)

void	preModuleEndStream (StreamContext const &sc, ModuleCallingContext const &mcc)

void	preModuleStreamBeginLumi (StreamContext const &sc, ModuleCallingContext const &mcc)

void	preModuleStreamBeginRun (StreamContext const &sc, ModuleCallingContext const &mcc)

void	preModuleStreamEndLumi (StreamContext const &sc, ModuleCallingContext const &mcc)

void	preModuleStreamEndRun (StreamContext const &sc, ModuleCallingContext const &mcc)

void	print (std::ostream &os) const override
	For debugging. More...

	RandomNumberGeneratorService (ParameterSet const &pset, ActivityRegistry &activityRegistry)

void	setEventCache (StreamID, std::vector< RandomEngineState > const &iStates) override

void	setLumiCache (LuminosityBlockIndex, std::vector< RandomEngineState > const &iStates) override

	~RandomNumberGeneratorService () override

Public Member Functions inherited from edm::RandomNumberGenerator
	RandomNumberGenerator ()

virtual	~RandomNumberGenerator ()

Static Public Member Functions
static void	fillDescriptions (ConfigurationDescriptions &descriptions)

Private Types
typedef std::vector< std::uint32_t >	VUint32

Private Member Functions
void	checkEngineType (std::string const &typeFromConfig, std::string const &typeFromEvent, std::string const &engineLabel) const

std::string	constructSaveFileName () const

void	createEnginesInVector (std::vector< LabelAndEngine > &engines, unsigned int seedOffset, unsigned int eventSeedOffset, std::vector< ModuleIDToEngine > &moduleIDVector)

RandomNumberGeneratorService const &	operator= (RandomNumberGeneratorService const &)=delete

void	postModuleStreamCheck (StreamContext const &sc, ModuleCallingContext const &mcc)

void	preModuleStreamCheck (StreamContext const &sc, ModuleCallingContext const &mcc)

	RandomNumberGeneratorService (RandomNumberGeneratorService const &)=delete

bool	readEngineState (std::istream &is, std::vector< RandomEngineState > &cache, std::string const &whichStates, bool &saveToCache)

void	readEventStatesFromTextFile (std::string const &fileName, std::vector< RandomEngineState > &cache)

void	readFromEvent (Event const &event)

void	readFromLuminosityBlock (LuminosityBlock const &lumi)

void	readLumiStatesFromTextFile (std::string const &fileName, std::vector< RandomEngineState > &cache)

void	readStatesFromFile (std::string const &fileName, std::vector< RandomEngineState > &cache, std::string const &whichStates)

void	readVector (std::istream &is, unsigned numItems, std::vector< std::uint32_t > &v)

void	resetEngineSeeds (LabelAndEngine &labelAndEngine, std::string const &engineName, VUint32 const &seeds, std::uint32_t offset1, std::uint32_t offset2)

void	restoreFromCache (std::vector< RandomEngineState > const &cache, std::vector< LabelAndEngine > &engines)

void	saveStatesToFile (std::string const &fileName, StreamID const &streamID, LuminosityBlockIndex const &lumiIndex)

void	snapShot (std::vector< LabelAndEngine > const &engines, std::vector< RandomEngineState > &cache)

void	writeStates (std::vector< RandomEngineState > const &v, std::ofstream &outFile)

void	writeVector (VUint32 const &v, std::ofstream &outFile)

Private Attributes
bool	enableChecking_

std::vector< std::vector< RandomEngineState > >	eventCache_

std::uint32_t	eventSeedOffset_

std::vector< std::vector< RandomEngineState > >	lumiCache_

std::vector< std::vector< LabelAndEngine > >	lumiEngines_

std::vector< std::vector< ModuleIDToEngine > >	lumiModuleIDToEngine_

unsigned int	nStreams_

std::vector< edm::propagate_const< std::shared_ptr< std::ofstream > > >	outFiles_

std::string	restoreFileName_

edm::InputTag	restoreStateBeginLumiTag_

edm::InputTag	restoreStateTag_

std::string	saveFileName_

std::atomic< bool >	saveFileNameRecorded_

std::map< std::string, SeedsAndName >	seedsAndNameMap_

std::vector< std::vector< LabelAndEngine > >	streamEngines_

std::vector< std::vector< ModuleIDToEngine > >	streamModuleIDToEngine_

bool	verbose_

Static Private Attributes
static const std::uint32_t	maxSeedHepJames = 900000000U

static const std::uint32_t	maxSeedRanecu = 2147483647U

static const std::vector< std::uint32_t >::size_type	maxSeeds = 65536U

static const std::uint32_t	maxSeedTRandom3 = 4294967295U

static const std::vector< std::uint32_t >::size_type	maxStates = 65536U

Detailed Description

Description: Manages random number engines for modules

Usage: See comments in base class, FWCore/Utilities/RandomNumberGenerator.h

Author: Chris Jones and W. David Dagenhart, created March 7, 2006 (originally in FWCore/Services)

Definition at line 52 of file RandomNumberGeneratorService.h.

Member Typedef Documentation

typedef std::vector<std::uint32_t> edm::service::RandomNumberGeneratorService::VUint32

private

Definition at line 124 of file RandomNumberGeneratorService.h.

Constructor & Destructor Documentation

edm::service::RandomNumberGeneratorService::RandomNumberGeneratorService	(	ParameterSet const &	pset,
		ActivityRegistry &	activityRegistry
	)

Definition at line 61 of file RandomNumberGeneratorService.cc.

                                                                                                   :
       nStreams_(0),
       saveFileName_(pset.getUntrackedParameter<std::string>("saveFileName")),
       saveFileNameRecorded_(false),
       restoreFileName_(pset.getUntrackedParameter<std::string>("restoreFileName")),
       enableChecking_(pset.getUntrackedParameter<bool>("enableChecking")),
       eventSeedOffset_(pset.getUntrackedParameter<unsigned>("eventSeedOffset")),
       verbose_(pset.getUntrackedParameter<bool>("verbose")) {
 
       if(pset.exists("restoreStateTag")) {
         restoreStateTag_ = pset.getUntrackedParameter<edm::InputTag>("restoreStateTag");
         if(restoreStateTag_.process() == "") {
           restoreStateTag_ = edm::InputTag(restoreStateTag_.label(), "", edm::InputTag::kSkipCurrentProcess);
         }
       } else {
         restoreStateTag_ = edm::InputTag(pset.getUntrackedParameter<std::string>("restoreStateLabel"), "", edm::InputTag::kSkipCurrentProcess);
       }
       restoreStateBeginLumiTag_ = edm::InputTag(restoreStateTag_.label(), "beginLumi", restoreStateTag_.process());
 
       if(!restoreFileName_.empty() && !restoreStateTag_.label().empty()) {
         throw Exception(errors::Configuration)
           << "In the configuration for the RandomNumberGeneratorService both\n"
           << "restoreFileName and restoreStateLabel were set to nonempty values\n"
           << "which is illegal.  It is impossible to restore the random engine\n"
           << "states two different ways in the same process.\n";
       }
 
       // The saveFileName must correspond to a file name without any path specification.
       // Throw if that is not true.
       if(!saveFileName_.empty() && (saveFileName_.find("/") != std::string::npos)) {
         throw Exception(errors::Configuration)
           << "The saveFileName parameter must be a simple file name with no path\n"
           << "specification. In the configuration, it was given the value \""
           << saveFileName_ << "\"\n";
       }
 
       std::uint32_t initialSeed;
       VUint32 initialSeedSet;
       std::string engineName;
 
       std::vector<std::string> pSets = pset.getParameterNamesForType<ParameterSet>();
       for(auto const& label : pSets) {
 
         ParameterSet const& modulePSet = pset.getParameterSet(label);
         engineName = modulePSet.getUntrackedParameter<std::string>("engineName", std::string("HepJamesRandom"));
 
         bool initialSeedExists = modulePSet.exists("initialSeed");
         bool initialSeedSetExists = modulePSet.exists("initialSeedSet");
 
         if(initialSeedExists && initialSeedSetExists) {
           throw Exception(errors::Configuration)
             << "For the module with the label \"" << label << "\",\n"
             << "both the parameters \"initialSeed\" and \"initialSeedSet\"\n"
             << "have been set in the configuration. You must set one or\n"
             << "the other.  It is illegal to set both.\n";
         } else if(!initialSeedExists && !initialSeedSetExists) {
           throw Exception(errors::Configuration)
             << "For the module with the label \"" << label << "\",\n"
             << "neither the parameter \"initialSeed\" nor \"initialSeedSet\"\n"
             << "has been set in the configuration. You must set one or\n"
             << "the other.\n";
         } else if(initialSeedExists) {
           initialSeed = modulePSet.getUntrackedParameter<std::uint32_t>("initialSeed");
           initialSeedSet.clear();
           initialSeedSet.push_back(initialSeed);
         } else if(initialSeedSetExists) {
           initialSeedSet = modulePSet.getUntrackedParameter<VUint32>("initialSeedSet");
         }
         seedsAndNameMap_.insert(std::pair<std::string, SeedsAndName>(label, SeedsAndName(initialSeedSet, engineName)));
 
         // For the CLHEP::RanecuEngine case, require a seed set containing exactly two seeds.
         if(engineName == std::string("RanecuEngine")) {
           if(initialSeedSet.size() != 2U) {
             throw Exception(errors::Configuration)
               << "Random engines of type \"RanecuEngine\" require 2 seeds\n"
               << "be specified with the parameter named \"initialSeedSet\".\n"
               << "Either \"initialSeedSet\" was not in the configuration\n"
               << "or its size was not 2 for the module with label \"" << label << "\".\n" ;
           }
           if(initialSeedSet[0] > maxSeedRanecu ||
              initialSeedSet[1] > maxSeedRanecu) {  // They need to fit in a 31 bit integer
             throw Exception(errors::Configuration)
               << "The RanecuEngine seeds should be in the range 0 to " << maxSeedRanecu << ".\n"
               << "The seeds passed to the RandomNumberGenerationService from the\n"
                  "configuration file were " << initialSeedSet[0] << " and " << initialSeedSet[1]
               << "\nThis was for the module with label \"" << label << "\".\n";
           }
         }
         // For the other engines, one seed is required
         else {
           if(initialSeedSet.size() != 1U) {
             throw Exception(errors::Configuration)
               << "Random engines of type \"HepJamesRandom\", \"TRandom3\" and \"MixMaxRng\" \n"
               << "require exactly 1 seed be specified in the configuration.\n"
               << "There were " << initialSeedSet.size() << " seeds set for the\n"
               << "module with label \"" << label << "\".\n" ;
           }
           if(engineName == "HepJamesRandom") {
             if(initialSeedSet[0] > maxSeedHepJames) {
               throw Exception(errors::Configuration)
                 << "The CLHEP::HepJamesRandom engine seed should be in the range 0 to " << maxSeedHepJames <<".\n"
                 << "The seed passed to the RandomNumberGenerationService from the\n"
                    "configuration file was " << initialSeedSet[0] << ".  This was for \n"
                 << "the module with label " << label << ".\n";
             }
           } else if(engineName == "MixMaxRng") {
             if(initialSeedSet[0] > maxSeedTRandom3) {
               throw Exception(errors::Configuration)
                 << "The CLHEP::MixMaxRng engine seed should be in the range 0 to " << maxSeedTRandom3 << ".\n"
                 << "The seed passed to the RandomNumberGenerationService from the\n"
                    "configuration file was " << initialSeedSet[0] << ".  This was for \n"
                 << "the module with label " << label << ".\n";
             }
           } else if(engineName == "TRandom3") {
             if(initialSeedSet[0] > maxSeedTRandom3) {
               throw Exception(errors::Configuration)
                 << "The CLHEP::MixMaxRng engine seed should be in the range 0 to " << maxSeedTRandom3 << ".\n"
                 << "The seed passed to the RandomNumberGenerationService from the\n"
                    "configuration file was " << initialSeedSet[0] << ".  This was for \n"
                 << "the module with label " << label << ".\n";
             }
           } else {
             throw Exception(errors::Configuration)
               << "The random engine name, \"" << engineName
               << "\", does not correspond to a supported engine.\n"
               << "This engine was configured for the module with label \"" << label << "\"";
           }
         }
       }
       activityRegistry.watchPreModuleConstruction(this, &RandomNumberGeneratorService::preModuleConstruction);
 
       activityRegistry.watchPreallocate(this, &RandomNumberGeneratorService::preallocate);
 
       if(enableChecking_) {
 
         activityRegistry.watchPreModuleBeginStream(this, &RandomNumberGeneratorService::preModuleBeginStream);
         activityRegistry.watchPostModuleBeginStream(this, &RandomNumberGeneratorService::postModuleBeginStream);
 
         activityRegistry.watchPreModuleEndStream(this, &RandomNumberGeneratorService::preModuleEndStream);
         activityRegistry.watchPostModuleEndStream(this, &RandomNumberGeneratorService::postModuleEndStream);
 
         activityRegistry.watchPreModuleStreamBeginRun(this, &RandomNumberGeneratorService::preModuleStreamBeginRun);
         activityRegistry.watchPostModuleStreamBeginRun(this, &RandomNumberGeneratorService::postModuleStreamBeginRun);
 
         activityRegistry.watchPreModuleStreamEndRun(this, &RandomNumberGeneratorService::preModuleStreamEndRun);
         activityRegistry.watchPostModuleStreamEndRun(this, &RandomNumberGeneratorService::postModuleStreamEndRun);
 
         activityRegistry.watchPreModuleStreamBeginLumi(this, &RandomNumberGeneratorService::preModuleStreamBeginLumi);
         activityRegistry.watchPostModuleStreamBeginLumi(this, &RandomNumberGeneratorService::postModuleStreamBeginLumi);
 
         activityRegistry.watchPreModuleStreamEndLumi(this, &RandomNumberGeneratorService::preModuleStreamEndLumi);
         activityRegistry.watchPostModuleStreamEndLumi(this, &RandomNumberGeneratorService::postModuleStreamEndLumi);
       }
 
     }

edm::service::RandomNumberGeneratorService::~RandomNumberGeneratorService ( )

override

Definition at line 218 of file RandomNumberGeneratorService.cc.

218 {

219 }

edm::service::RandomNumberGeneratorService::RandomNumberGeneratorService ( RandomNumberGeneratorService const & )

privatedelete

Member Function Documentation

void edm::service::RandomNumberGeneratorService::checkEngineType	(	std::string const &	typeFromConfig,
		std::string const &	typeFromEvent,
		std::string const &	engineLabel
	)		const

private

Definition at line 849 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, and Exception.

Referenced by restoreFromCache().

                                                                                       {
       if(typeFromConfig != typeFromEvent) {
         throw Exception(errors::Configuration)
           << "The RandomNumberGeneratorService is trying to restore\n"
           << "the state of the random engine for the module \""
           << engineLabel << "\".  An\n"
           << "error was detected because the type of the engine in the\n"
           << "input file and the configuration file do not match.\n"
           << "In the configuration file the type is \"" << typeFromConfig
           << "\".\nIn the input file the type is \"" << typeFromEvent << "\".  If\n"
           << "you are not generating any random numbers in this module, then\n"
           << "remove the line in the configuration file that gives it\n"
           << "a seed and the error will go away.  Otherwise, you must give\n"
           << "this module the same engine type in the configuration file or\n"
           << "stop trying to restore the random engine state.\n";
       }
     }

std::unique_ptr< CLHEP::HepRandomEngine > edm::service::RandomNumberGeneratorService::cloneEngine ( LuminosityBlockIndex const & )

overridevirtual

This function is not intended for general use. It is intended for the special case where multiple instances of Pythia 8 will be run concurrently and we want them to be initialized exactly the same. In this special case, the luminosity block engine(s) owned by the service should not be used to generate random numbers in between calls to cloneEngine, because the clone will be in the state that existed at the moment of cloning. Before initializing Pythia, this function should be used to clone the engine owned by the service and the cloned random engine should be used to generate numbers for initialization so that all initializations in the process get identical sequences of random numbers.

Implements edm::RandomNumberGenerator.

Definition at line 301 of file RandomNumberGeneratorService.cc.

References Exception, getEngine(), and edm::errors::Unknown.

                                                {
       CLHEP::HepRandomEngine& existingEngine = getEngine(lumiIndex);
 
       std::vector<unsigned long> stateL = existingEngine.put();
       long seedL = existingEngine.getSeed();
       std::unique_ptr<CLHEP::HepRandomEngine> newEngine;
       if (stateL[0] == CLHEP::engineIDulong<CLHEP::HepJamesRandom>()) {
         newEngine = std::make_unique<CLHEP::HepJamesRandom>(seedL);
       } else if (stateL[0] == CLHEP::engineIDulong<CLHEP::RanecuEngine>()) {
         newEngine = std::make_unique<CLHEP::RanecuEngine>();
       } else if (stateL[0] == CLHEP::engineIDulong<CLHEP::MixMaxRng>()) {
         newEngine = std::make_unique<CLHEP::MixMaxRng>(seedL);
       } else if (stateL[0] == CLHEP::engineIDulong<TRandomAdaptor>()) {
         newEngine = std::make_unique<TRandomAdaptor>(seedL);
       } else {
         // Sanity check, it should not be possible for this to happen.
         throw Exception(errors::Unknown) << "The RandomNumberGeneratorService is trying to clone unknown engine type\n";
       }
       newEngine->get(stateL);
       return newEngine;
     }

std::string edm::service::RandomNumberGeneratorService::constructSaveFileName ( ) const

private

Definition at line 942 of file RandomNumberGeneratorService.cc.

References createBeamHaloJobs::directory, saveFileName_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by postEventRead().

                                                                         {
       char directory[1500];
       std::string fullName(getcwd(directory, sizeof(directory)) ? directory : "/PathIsTooBig");
       fullName += "/" + saveFileName_;
       return fullName;
     }

void edm::service::RandomNumberGeneratorService::consumes ( ConsumesCollector && iC ) const

overridevirtual

Implements edm::RandomNumberGenerator.

Definition at line 222 of file RandomNumberGeneratorService.cc.

References edm::InLumi, restoreStateBeginLumiTag_, and restoreStateTag_.

                                                                        {
        iC.consumes<RandomEngineStates, InLumi>(restoreStateBeginLumiTag_);
        iC.consumes<RandomEngineStates>(restoreStateTag_);
     }

void edm::service::RandomNumberGeneratorService::createEnginesInVector	(	std::vector< LabelAndEngine > &	engines,
		unsigned int	seedOffset,
		unsigned int	eventSeedOffset,
		std::vector< ModuleIDToEngine > &	moduleIDVector
	)

private

Definition at line 1155 of file RandomNumberGeneratorService.cc.

References mps_fire::i, label, SiStripPI::max, dataset::name, resetEngineSeeds(), seedsAndNameMap_, jetUpdater_cfi::sort, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by preallocate().

                                                                                                      {
       // The vectors we will fill here will be the same size as
       // or smaller than seedsAndNameMap_.
       engines.reserve(seedsAndNameMap_.size());
       moduleIDVector.reserve(seedsAndNameMap_.size());
 
       for(auto const& i : seedsAndNameMap_) {
         unsigned int moduleID = i.second.moduleID();
         if(moduleID != std::numeric_limits<unsigned int>::max()) {
           std::string const& label = i.first;
           std::string const& name = i.second.engineName();
           VUint32 const& seeds = i.second.seeds();
 
           if(name == "RanecuEngine") {
             std::shared_ptr<CLHEP::HepRandomEngine> engine = std::make_shared<CLHEP::RanecuEngine>();
             engines.emplace_back(label, seeds, engine);
             resetEngineSeeds(engines.back(), name, seeds, seedOffset, eventSeedOffset);
           }
           // For the other engines, one seed is required
           else {
             long int seedL = static_cast<long int>(seeds[0]);
 
             if(name == "HepJamesRandom") {
               std::shared_ptr<CLHEP::HepRandomEngine> engine = std::make_shared<CLHEP::HepJamesRandom>(seedL);
               engines.emplace_back(label, seeds, engine);
               if(seedOffset != 0 || eventSeedOffset != 0) {
                 resetEngineSeeds(engines.back(), name, seeds, seedOffset, eventSeedOffset);
               }
             } else if(name == "MixMaxRng") {
               std::shared_ptr<CLHEP::HepRandomEngine> engine = std::make_shared<CLHEP::MixMaxRng>(seedL);
               engines.emplace_back(label, seeds, engine);
               if(seedOffset != 0 || eventSeedOffset != 0) {
                 resetEngineSeeds(engines.back(), name, seeds, seedOffset, eventSeedOffset);
               }
             } else { // TRandom3, currently the only other possibility
 
               // There is a dangerous conversion from std::uint32_t to long
               // that occurs above. In the next 2 lines we check the
               // behavior is what we need for the service to work
               // properly.  This conversion is forced on us by the
               // CLHEP and ROOT interfaces. If the assert ever starts
               // to fail we will have to come up with a way to deal
               // with this.
               std::uint32_t seedu32 = static_cast<std::uint32_t>(seedL);
               assert(seeds[0] == seedu32);
 
               std::shared_ptr<CLHEP::HepRandomEngine> engine = std::make_shared<TRandomAdaptor>(seedL);
               engines.emplace_back(label, seeds, engine);
               if(seedOffset != 0 || eventSeedOffset != 0) {
                 resetEngineSeeds(engines.back(), name, seeds, seedOffset, eventSeedOffset);
               }
             }
           }
           moduleIDVector.emplace_back(&engines.back(), moduleID);
         } // if moduleID valid
       } // loop over seedsAndMap
       std::sort(moduleIDVector.begin(), moduleIDVector.end());
     }

void edm::service::RandomNumberGeneratorService::fillDescriptions ( ConfigurationDescriptions & descriptions )

static

Definition at line 364 of file RandomNumberGeneratorService.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addNode(), edm::ParameterSetDescription::addUntracked(), edm::friendlyname::emptyString(), edm::RequireZeroOrMore, AlCaHLTBitMon_QueryRunRegistry::string, mitigatedMETSequence_cff::U, and heppy_batch::val.

                                                                                           {
       ParameterSetDescription desc;
 
       std::string emptyString;
       edm::InputTag emptyInputTag("", "", "");
 
       desc.addNode( edm::ParameterDescription<edm::InputTag>("restoreStateTag", emptyInputTag, false) xor
                     edm::ParameterDescription<std::string>("restoreStateLabel", emptyString, false) );
 
       desc.addUntracked<std::string>("saveFileName", emptyString);
       desc.addUntracked<std::string>("restoreFileName", emptyString);
       desc.addUntracked<bool>("enableChecking", false);
       desc.addUntracked<unsigned>("eventSeedOffset", 0U);
       desc.addUntracked<bool>("verbose", false);
 
       ParameterSetDescription val;
       val.addOptionalUntracked<std::uint32_t>("initialSeed");
       val.addOptionalUntracked<std::vector<std::uint32_t> >("initialSeedSet");
       val.addOptionalUntracked<std::string>("engineName");
 
       ParameterWildcard<ParameterSetDescription> wnode("*", RequireZeroOrMore, true, val);
       wnode.setComment("The name of each ParameterSet will be the associated module label.");
       desc.addNode(wnode);
 
       descriptions.add("RandomNumberGeneratorService", desc);
     }

CLHEP::HepRandomEngine & edm::service::RandomNumberGeneratorService::getEngine ( StreamID const & streamID )

overridevirtual

Use this engine in event methods.

Use the next 2 functions to get the random number engine. These are the only functions most modules should call.

Implements edm::RandomNumberGenerator.

Definition at line 228 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, Exception, edm::CurrentModuleOnThread::getCurrentModuleOnThread(), edm::ModuleDescription::id(), edm::errors::LogicError, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, edm::ModuleCallingContext::moduleDescription(), edm::ModuleDescription::moduleLabel(), streamModuleIDToEngine_, edmPickEvents::target, and edm::StreamID::value().

Referenced by cloneEngine().

                                                                     {
 
       ModuleCallingContext const* mcc = CurrentModuleOnThread::getCurrentModuleOnThread();
       if(mcc == nullptr) {
         throw Exception(errors::LogicError)
           << "RandomNumberGeneratorService::getEngine\n"
              "Requested a random number engine from the RandomNumberGeneratorService\n"
              "when no module was active. ModuleCallingContext is null\n";
       }
       unsigned int moduleID = mcc->moduleDescription()->id();
 
       std::vector<ModuleIDToEngine>& moduleIDVector = streamModuleIDToEngine_.at(streamID.value());
       ModuleIDToEngine target(nullptr, moduleID);
       std::vector<ModuleIDToEngine>::iterator iter = std::lower_bound(moduleIDVector.begin(),
                                                                       moduleIDVector.end(),
                                                                       target);
       if(iter == moduleIDVector.end() || iter->moduleID() != moduleID) {
         throw Exception(errors::Configuration)
           << "The module with label \""
           << mcc->moduleDescription()->moduleLabel()
           << "\" requested a random number engine from the \n"
              "RandomNumberGeneratorService, but that module was not configured\n"
              "for random numbers.  An engine is created only if a seed(s) is provided\n"
              "in the configuration file.  Please add the following PSet to the\n"
              "configuration file for the RandomNumberGeneratorService:\n\n"
              "  " << mcc->moduleDescription()->moduleLabel() << " = cms.PSet(\n"
              "    initialSeed = cms.untracked.uint32(your_seed),\n"
              "    engineName = cms.untracked.string('TRandom3')\n"
              "  )\n"
              "where you replace \"your_seed\" with a number and add a comma if necessary\n"
             "The \"engineName\" parameter is optional. If absent the default is \"HepJamesRandom\".\n";
 
       }
       return *iter->labelAndEngine()->engine();
     }

CLHEP::HepRandomEngine & edm::service::RandomNumberGeneratorService::getEngine ( LuminosityBlockIndex const & luminosityBlockIndex )

overridevirtual

Use this engine in the global begin luminosity block method.

Implements edm::RandomNumberGenerator.

Definition at line 265 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, Exception, edm::CurrentModuleOnThread::getCurrentModuleOnThread(), edm::ModuleDescription::id(), edm::errors::LogicError, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, lumiModuleIDToEngine_, edm::ModuleCallingContext::moduleDescription(), edm::ModuleDescription::moduleLabel(), edmPickEvents::target, and edm::LuminosityBlockIndex::value().

                                                                                  {
 
       ModuleCallingContext const* mcc = CurrentModuleOnThread::getCurrentModuleOnThread();
       if(mcc == nullptr) {
         throw Exception(errors::LogicError)
           << "RandomNumberGeneratorService::getEngine\n"
              "Requested a random number engine from the RandomNumberGeneratorService\n"
              "when no module was active. ModuleCallingContext is null\n";
       }
       unsigned int moduleID = mcc->moduleDescription()->id();
 
       std::vector<ModuleIDToEngine>& moduleIDVector = lumiModuleIDToEngine_.at(lumiIndex.value());
       ModuleIDToEngine target(nullptr, moduleID);
       std::vector<ModuleIDToEngine>::iterator iter = std::lower_bound(moduleIDVector.begin(),
                                                                       moduleIDVector.end(),
                                                                       target);
       if(iter == moduleIDVector.end() || iter->moduleID() != moduleID) {
         throw Exception(errors::Configuration)
           << "The module with label \""
           << mcc->moduleDescription()->moduleLabel()
           << "\" requested a random number engine from the \n"
              "RandomNumberGeneratorService, but that module was not configured\n"
              "for random numbers.  An engine is created only if a seed(s) is provided\n"
              "in the configuration file.  Please add the following PSet to the\n"
              "configuration file for the RandomNumberGeneratorService:\n\n"
              "  " << mcc->moduleDescription()->moduleLabel() << " = cms.PSet(\n"
              "    initialSeed = cms.untracked.uint32(your_seed),\n"
              "    engineName = cms.untracked.string('TRandom3')\n"
              "  )\n"
              "where you replace \"your_seed\" with a number and add a comma if necessary\n"
             "The \"engineName\" parameter is optional. If absent the default is \"HepJamesRandom\".\n";
 
       }
       return *iter->labelAndEngine()->engine();
     }

std::vector< RandomEngineState > const & edm::service::RandomNumberGeneratorService::getEventCache ( StreamID const & streamID ) const

overridevirtual

Implements edm::RandomNumberGenerator.

Definition at line 572 of file RandomNumberGeneratorService.cc.

References eventCache_, and edm::StreamID::value().

                                                                               {
       return eventCache_.at(streamID.value());
     }

std::vector< RandomEngineState > const & edm::service::RandomNumberGeneratorService::getLumiCache ( LuminosityBlockIndex const & lumiIndex ) const

overridevirtual

These two are used by the RandomEngineStateProducer.

Implements edm::RandomNumberGenerator.

Definition at line 567 of file RandomNumberGeneratorService.cc.

References lumiCache_, and edm::LuminosityBlockIndex::value().

                                                                                           {
       return lumiCache_.at(lumiIndex.value());
     }

std::uint32_t edm::service::RandomNumberGeneratorService::mySeed ( ) const

overridevirtual

This returns the seed from the configuration. In the unusual case where an an engine type takes multiple seeds to initialize a sequence, this function only returns the first. As a general rule, this function should not be used, but is available for backward compatibility and debugging. It might be useful for some types of tests. Using this to seed engines constructed in modules is not recommended because (unless done very carefully) it will create duplicate sequences in different threads and/or data races. Also, if engines are created by modules the replay mechanism will be broken. Because it is dangerous and could be misused, this function might be deleted someday if we ever find time to delete all uses of it in CMSSW. There are of order 10 last time I checked ...

Implements edm::RandomNumberGenerator.

Definition at line 331 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, Exception, edm::CurrentModuleOnThread::getCurrentModuleOnThread(), label, edm::errors::LogicError, edm::ModuleCallingContext::moduleDescription(), edm::ModuleDescription::moduleLabel(), seedsAndNameMap_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                {
       std::string label;
       ModuleCallingContext const* mcc = CurrentModuleOnThread::getCurrentModuleOnThread();
       if(mcc == nullptr) {
         throw Exception(errors::LogicError)
           << "RandomNumberGeneratorService::getEngine()\n"
           "Requested a random number engine from the RandomNumberGeneratorService\n"
           "from an unallowed transition. ModuleCallingContext is null\n";
       } else {
         label = mcc->moduleDescription()->moduleLabel();
       }
 
       std::map<std::string, SeedsAndName>::const_iterator iter = seedsAndNameMap_.find(label);
       if(iter == seedsAndNameMap_.end()) {
         throw Exception(errors::Configuration)
           << "The module with label \""
           << label
           << "\" requested a random number seed from the \n"
              "RandomNumberGeneratorService, but that module was not configured\n"
              "for random numbers.  An engine is created only if a seed(s) is provided\n"
              "in the configuration file.  Please add the following PSet to the\n"
              "configuration file for the RandomNumberGeneratorService:\n\n"
              "  " << label << " = cms.PSet(\n"
              "    initialSeed = cms.untracked.uint32(your_seed),\n"
              "    engineName = cms.untracked.string('TRandom3')\n"
              "  )\n"
              "where you replace \"your_seed\" with a number and add a comma if necessary\n"
              "The \"engineName\" parameter is optional. If absent the default is \"HepJamesRandom\".\n";
       }
       return iter->second.seeds()[0];
     }

RandomNumberGeneratorService const& edm::service::RandomNumberGeneratorService::operator= ( RandomNumberGeneratorService const & )

privatedelete

void edm::service::RandomNumberGeneratorService::postEventRead ( Event const & event )

overridevirtual

Implements edm::RandomNumberGenerator.

Definition at line 463 of file RandomNumberGeneratorService.cc.

References constructSaveFileName(), eventCache_, edm::InputTag::label(), readFromEvent(), restoreFromCache(), restoreStateTag_, saveFileName_, saveFileNameRecorded_, saveStatesToFile(), snapShot(), streamEngines_, edm::Event::streamID(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                   {
 
       if(!restoreStateTag_.label().empty()) {
 
         // This initializes the cache before readFromEvent
         snapShot(streamEngines_[event.streamID()], eventCache_[event.streamID()]);
 
         // copy from Event to event cache
         readFromEvent(event);
 
         // copy from event cache to engines
         restoreFromCache(eventCache_[event.streamID()], streamEngines_[event.streamID()]);
 
       } else {
         // copy from engines to event cache
         snapShot(streamEngines_[event.streamID()], eventCache_[event.streamID()]);
       }
 
       // if requested write text file from both caches
       if(!saveFileName_.empty())  {
         saveStatesToFile(saveFileName_, event.streamID(), event.getLuminosityBlock().index());
         bool expected = false;
         if(saveFileNameRecorded_.compare_exchange_strong(expected, true)) {
           std::string fullName = constructSaveFileName();
           Service<JobReport> reportSvc;
           reportSvc->reportRandomStateFile(fullName);
         }
       }
     }

void edm::service::RandomNumberGeneratorService::postModuleBeginStream	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

Definition at line 512 of file RandomNumberGeneratorService.cc.

References postModuleStreamCheck().

Referenced by RandomNumberGeneratorService().

                                                                                                                 {
       postModuleStreamCheck(sc, mcc);
     }

void edm::service::RandomNumberGeneratorService::postModuleEndStream	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

Definition at line 522 of file RandomNumberGeneratorService.cc.

References postModuleStreamCheck().

Referenced by RandomNumberGeneratorService().

                                                                                                               {
       postModuleStreamCheck(sc, mcc);
     }

void edm::service::RandomNumberGeneratorService::postModuleStreamBeginLumi	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

Definition at line 552 of file RandomNumberGeneratorService.cc.

References postModuleStreamCheck().

Referenced by RandomNumberGeneratorService().

                                                                                                                     {
       postModuleStreamCheck(sc, mcc);
     }

void edm::service::RandomNumberGeneratorService::postModuleStreamBeginRun	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

Definition at line 532 of file RandomNumberGeneratorService.cc.

References postModuleStreamCheck().

Referenced by RandomNumberGeneratorService().

                                                                                                                    {
       postModuleStreamCheck(sc, mcc);
     }

void edm::service::RandomNumberGeneratorService::postModuleStreamCheck	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

private

Definition at line 662 of file RandomNumberGeneratorService.cc.

References enableChecking_, edm::service::RandomNumberGeneratorService::LabelAndEngine::engine(), Exception, edm::ModuleDescription::id(), edm::errors::LogicError, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, edm::ModuleCallingContext::moduleDescription(), edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), edm::StreamContext::streamID(), streamModuleIDToEngine_, edmPickEvents::target, and edm::StreamID::value().

Referenced by postModuleBeginStream(), postModuleEndStream(), postModuleStreamBeginLumi(), postModuleStreamBeginRun(), postModuleStreamEndLumi(), and postModuleStreamEndRun().

                                                                                                                 {
       if(enableChecking_) {
         unsigned int moduleID = mcc.moduleDescription()->id();
         std::vector<ModuleIDToEngine>& moduleIDVector = streamModuleIDToEngine_.at(sc.streamID().value());
         ModuleIDToEngine target(nullptr, moduleID);
         std::vector<ModuleIDToEngine>::iterator iter = std::lower_bound(moduleIDVector.begin(),
                                                                         moduleIDVector.end(),
                                                                         target);
         if(iter != moduleIDVector.end() && iter->moduleID() == moduleID) {
           LabelAndEngine* labelAndEngine = iter->labelAndEngine();
           if(iter->engineState() != labelAndEngine->engine()->put()) {
             throw Exception(errors::LogicError)
               << "It is illegal to generate random numbers during beginStream, endStream,\n"
                  "beginRun, endRun, beginLumi, endLumi because that makes it very difficult\n"
                  "to replay the processing of individual events.  Random numbers were\n"
                  "generated during one of these methods for the module with class name\n\""
               << mcc.moduleDescription()->moduleName() << "\" "
                  "and module label \"" << mcc.moduleDescription()->moduleLabel() << "\"\n";
           }
         }
       }
     }

void edm::service::RandomNumberGeneratorService::postModuleStreamEndLumi	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

Definition at line 562 of file RandomNumberGeneratorService.cc.

References postModuleStreamCheck().

Referenced by RandomNumberGeneratorService().

                                                                                                                   {
       postModuleStreamCheck(sc, mcc);
     }

void edm::service::RandomNumberGeneratorService::postModuleStreamEndRun	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

Definition at line 542 of file RandomNumberGeneratorService.cc.

References postModuleStreamCheck().

Referenced by RandomNumberGeneratorService().

                                                                                                                  {
       postModuleStreamCheck(sc, mcc);
     }

void edm::service::RandomNumberGeneratorService::preallocate ( SystemBounds const & sb )

Definition at line 400 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, gather_cfg::cout, createEnginesInVector(), eventCache_, eventSeedOffset_, Exception, lumiCache_, lumiEngines_, lumiModuleIDToEngine_, edm::service::SystemBounds::maxNumberOfConcurrentLuminosityBlocks(), edm::service::SystemBounds::maxNumberOfStreams(), nStreams_, outFiles_, print(), readEventStatesFromTextFile(), readLumiStatesFromTextFile(), restoreFileName_, restoreFromCache(), saveFileName_, snapShot(), streamEngines_, streamModuleIDToEngine_, and verbose_.

Referenced by RandomNumberGeneratorService().

                                                                     {
 
       nStreams_ = sb.maxNumberOfStreams();
       assert(nStreams_ >= 1);
       if(!restoreFileName_.empty() && nStreams_ != 1) {
         throw Exception(errors::Configuration)
           << "Configuration is illegal. The RandomNumberGeneratorService is configured\n"
           << "to run replay using a text file to input the random engine states and\n"
           << "the number of streams is greater than 1. Either set the\n"
           << "parameter named \"restoreFileName\" in the RandomNumberGeneratorService\n"
           << "to the empty string or set the parameter \"numberOfStreams\" in the top\n"
           << "level options parameter set to 1. (Probably these are the default values\n"
           << "and just not setting the parameters will also work)\n";
       }
       unsigned int nConcurrentLumis = sb.maxNumberOfConcurrentLuminosityBlocks();
 
       streamModuleIDToEngine_.resize(nStreams_);
       lumiModuleIDToEngine_.resize(nConcurrentLumis);
       streamEngines_.resize(nStreams_);
       lumiEngines_.resize(nConcurrentLumis);
       eventCache_.resize(nStreams_);
       lumiCache_.resize(nConcurrentLumis);
       outFiles_.resize(nStreams_);
 
       for(unsigned int iStream = 0; iStream < nStreams_; ++iStream) {
         unsigned int seedOffset = iStream;
         createEnginesInVector(streamEngines_[iStream], seedOffset, eventSeedOffset_, streamModuleIDToEngine_[iStream]);
         if(!saveFileName_.empty())  {
           outFiles_[iStream] = std::make_shared<std::ofstream>(); // propagate_const<T> has no reset() function
         }
       }
       for(unsigned int iLumi = 0; iLumi < nConcurrentLumis; ++iLumi) {
         unsigned int seedOffset = nStreams_;
         createEnginesInVector(lumiEngines_[iLumi], seedOffset, 0, lumiModuleIDToEngine_[iLumi]);
         snapShot(lumiEngines_[iLumi], lumiCache_[iLumi]);
         if(!restoreFileName_.empty()) {
           readLumiStatesFromTextFile(restoreFileName_, lumiCache_[iLumi]);
         }
       }
 
       if(!restoreFileName_.empty()) {
         // There is guaranteed to be one stream in this case
         snapShot(streamEngines_[0], eventCache_[0]);
         readEventStatesFromTextFile(restoreFileName_, eventCache_[0]);
         restoreFromCache(eventCache_[0], streamEngines_[0]);
       }
       if(verbose_) {
         print(std::cout);
       }
     }

void edm::service::RandomNumberGeneratorService::preBeginLumi ( LuminosityBlock const & lumi )

overridevirtual

Implements edm::RandomNumberGenerator.

Definition at line 452 of file RandomNumberGeneratorService.cc.

References edm::LuminosityBlock::index(), edm::InputTag::label(), lumiCache_, lumiEngines_, readFromLuminosityBlock(), restoreFromCache(), and restoreStateTag_.

                                                                           {
 
       if(!restoreStateTag_.label().empty()) {
         // Copy from a product in the LuminosityBlock to cache for a particular luminosityBlockIndex
         readFromLuminosityBlock(lumi);
       }
       // Copy from cache to engine the state for a particular luminosityBlockIndex
       restoreFromCache(lumiCache_[lumi.index()], lumiEngines_[lumi.index()]);
     }

void edm::service::RandomNumberGeneratorService::preModuleBeginStream	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

These next 12 functions are only used to check that random numbers are not being generated in these methods when enable checking is configured on.

Definition at line 507 of file RandomNumberGeneratorService.cc.

References preModuleStreamCheck().

Referenced by RandomNumberGeneratorService().

                                                                                                                {
       preModuleStreamCheck(sc, mcc);
     }

void edm::service::RandomNumberGeneratorService::preModuleConstruction ( ModuleDescription const & description )

Definition at line 392 of file RandomNumberGeneratorService.cc.

References edm::ModuleDescription::id(), edm::ModuleDescription::moduleLabel(), and seedsAndNameMap_.

Referenced by RandomNumberGeneratorService().

                                                                                             {
       std::map<std::string, SeedsAndName>::iterator iter = seedsAndNameMap_.find(description.moduleLabel());
       if(iter != seedsAndNameMap_.end()) {
         iter->second.setModuleID(description.id());
       }
     }

void edm::service::RandomNumberGeneratorService::preModuleEndStream	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

Definition at line 517 of file RandomNumberGeneratorService.cc.

References preModuleStreamCheck().

Referenced by RandomNumberGeneratorService().

                                                                                                              {
       preModuleStreamCheck(sc, mcc);
     }

void edm::service::RandomNumberGeneratorService::preModuleStreamBeginLumi	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

Definition at line 547 of file RandomNumberGeneratorService.cc.

References preModuleStreamCheck().

Referenced by RandomNumberGeneratorService().

                                                                                                                    {
       preModuleStreamCheck(sc, mcc);
     }

void edm::service::RandomNumberGeneratorService::preModuleStreamBeginRun	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

Definition at line 527 of file RandomNumberGeneratorService.cc.

References preModuleStreamCheck().

Referenced by RandomNumberGeneratorService().

                                                                                                                   {
       preModuleStreamCheck(sc, mcc);
     }

void edm::service::RandomNumberGeneratorService::preModuleStreamCheck	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

private

Definition at line 646 of file RandomNumberGeneratorService.cc.

References enableChecking_, edm::service::RandomNumberGeneratorService::LabelAndEngine::engine(), edm::ModuleDescription::id(), pfDeepBoostedJetPreprocessParams_cfi::lower_bound, edm::ModuleCallingContext::moduleDescription(), edm::StreamContext::streamID(), streamModuleIDToEngine_, edmPickEvents::target, and edm::StreamID::value().

Referenced by preModuleBeginStream(), preModuleEndStream(), preModuleStreamBeginLumi(), preModuleStreamBeginRun(), preModuleStreamEndLumi(), and preModuleStreamEndRun().

                                                                                                                {
       if(enableChecking_) {
         unsigned int moduleID = mcc.moduleDescription()->id();
         std::vector<ModuleIDToEngine>& moduleIDVector = streamModuleIDToEngine_.at(sc.streamID().value());
         ModuleIDToEngine target(nullptr, moduleID);
         std::vector<ModuleIDToEngine>::iterator iter = std::lower_bound(moduleIDVector.begin(),
                                                                         moduleIDVector.end(),
                                                                         target);
         if(iter != moduleIDVector.end() && iter->moduleID() == moduleID) {
           LabelAndEngine* labelAndEngine = iter->labelAndEngine();
           iter->setEngineState(labelAndEngine->engine()->put());
         }
       }
     }

void edm::service::RandomNumberGeneratorService::preModuleStreamEndLumi	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

Definition at line 557 of file RandomNumberGeneratorService.cc.

References preModuleStreamCheck().

Referenced by RandomNumberGeneratorService().

                                                                                                                  {
       preModuleStreamCheck(sc, mcc);
     }

void edm::service::RandomNumberGeneratorService::preModuleStreamEndRun	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

Definition at line 537 of file RandomNumberGeneratorService.cc.

References preModuleStreamCheck().

Referenced by RandomNumberGeneratorService().

                                                                                                                 {
       preModuleStreamCheck(sc, mcc);
     }

void edm::service::RandomNumberGeneratorService::print ( std::ostream & os ) const

overridevirtual

For debugging.

Implements edm::RandomNumberGenerator.

Definition at line 577 of file RandomNumberGeneratorService.cc.

References enableChecking_, mps_splice::entry, eventSeedOffset_, mps_fire::i, gen::k, lumiEngines_, nStreams_, restoreFileName_, restoreStateBeginLumiTag_, restoreStateTag_, saveFileName_, saveFileNameRecorded_, seedsAndNameMap_, streamEngines_, AlCaHLTBitMon_QueryRunRegistry::string, heppy_batch::val, and verbose_.

Referenced by preallocate().

                                                             {
 
       os << "\n\nRandomNumberGeneratorService dump\n\n";
 
       os << "    Contents of seedsAndNameMap (label moduleID engineType seeds)\n";
       for(auto const& entry : seedsAndNameMap_) {
         os << "        " << entry.first
            << "  " << entry.second.moduleID()
            << "  " << entry.second.engineName();
         for(auto val : entry.second.seeds()) {
           os << "  " << val;
         }
         os << "\n";
       }
       os << "    nStreams_ = " << nStreams_ << "\n";
       os << "    saveFileName_ = " << saveFileName_ << "\n";
       os << "    saveFileNameRecorded_ = " << saveFileNameRecorded_ << "\n";
       os << "    restoreFileName_ = " << restoreFileName_ << "\n";
       os << "    enableChecking_ = " << enableChecking_ << "\n";
       os << "    eventSeedOffset_ = " << eventSeedOffset_ << "\n";
       os << "    verbose_ = " << verbose_ << "\n";
       os << "    restoreStateTag_ = " << restoreStateTag_ << "\n";
       os << "    restoreStateBeginLumiTag_ = " << restoreStateBeginLumiTag_ << "\n";
 
       os << "\n    streamEngines_\n";
       unsigned int iStream = 0;
       for(auto const& k : streamEngines_) {
         os << "        Stream " << iStream << "\n";
         for(auto const& i : k) {
           os << "        " << i.label();
           for(auto const& j : i.seeds()) {
             os << " " << j;
           }
           os << " " << i.engine()->name();
           if(i.engine()->name() == std::string("HepJamesRandom")) {
             os << "  " << i.engine()->getSeed();
           } else if(i.engine()->name() == std::string("MixMaxRng")) {
             os << "  " << i.engine()->getSeed();
           } else {
             os << "  engine does not know seeds";
           }
           os << "\n";
         }
         ++iStream;
       }
       os << "\n    lumiEngines_\n";
       unsigned int iLumi = 0;
       for(auto const& k : lumiEngines_) {
         os << "        lumiIndex " << iLumi << "\n";
         for(auto const& i : k) {
           os << "        " << i.label();
           for(auto const& j : i.seeds()) {
             os << " " << j;
           }
           os << " " << i.engine()->name();
           if(i.engine()->name() == std::string("HepJamesRandom")) {
             os << "  " << i.engine()->getSeed();
           } else if(i.engine()->name() == std::string("MixMaxRng")) {
             os << "  " << i.engine()->getSeed();
           } else {
             os << "  engine does not know seeds";
           }
           os << "\n";
         }
         ++iLumi;
       }
     }

bool edm::service::RandomNumberGeneratorService::readEngineState	(	std::istream &	is,
		std::vector< RandomEngineState > &	cache,
		std::string const &	whichStates,
		bool &	saveToCache
	)

private

Definition at line 989 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, Exception, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, maxSeeds, maxStates, readVector(), restoreFileName_, RandomEngineState::setLabel(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by readStatesFromFile().

                                                                           {
       std::string leading;
       std::string trailing;
       std::string moduleLabel;
       std::vector<std::uint32_t>::size_type seedVectorSize;
       std::vector<std::uint32_t> seedVector;
       std::vector<std::uint32_t>::size_type stateVectorSize;
       std::vector<std::uint32_t> stateVector;
 
       // First we need to look for the special strings
       // that mark the end of the file and beginning and
       // and end of the data for different sections.
 
       is >> leading;
       if(!is.good()) {
         throw Exception(errors::Configuration)
           << "File \"" << restoreFileName_
           << "\" is ill-structured or otherwise corrupted.\n"
           << "Cannot read next field and did not hit the end yet.\n";
       }
 
       // This marks the end of the file. We are done.
       if(leading == std::string("</RandomEngineStates>")) return false;
 
       // This marks the end of a section of the data
       if(leading == std::string("</Event>") ||
           leading == std::string("</Lumi>")) {
         saveToCache = false;
         return true;
       }
 
       // This marks the beginning of a section
       if(leading == std::string("<Event>") ||
           leading == std::string("<Lumi>")) {
         saveToCache = (leading == whichStates);
         return true;
       }
 
       // Process the next engine state
 
       is >> moduleLabel >> trailing;
       if(!is.good() ||
           leading != std::string("<ModuleLabel>") ||
           trailing != std::string("</ModuleLabel>")) {
         throw Exception(errors::Configuration)
           << "File \"" << restoreFileName_
           << "\" is ill-structured or otherwise corrupted.\n"
           << "Cannot read a module label when restoring random engine states.\n";
       }
 
       is >> leading >> seedVectorSize >> trailing;
       if(!is.good() ||
           leading != std::string("<SeedLength>") ||
           trailing != std::string("</SeedLength>")) {
         throw Exception(errors::Configuration)
           << "File \"" << restoreFileName_
           << "\" is ill-structured or otherwise corrupted.\n"
           << "Cannot read seed vector length when restoring random engine states.\n";
       }
 
       is >> leading;
       if(!is.good() ||
           leading != std::string("<InitialSeeds>")) {
         throw Exception(errors::Configuration)
           << "File \"" << restoreFileName_
           << "\" is ill-structured or otherwise corrupted.\n"
           << "Cannot read beginning of InitialSeeds when restoring random engine states.\n";
       }
 
       if(seedVectorSize > maxSeeds) {
         throw Exception(errors::Configuration)
           << "File \"" << restoreFileName_
           << "\" is ill-structured or otherwise corrupted.\n"
           << "The number of seeds exceeds 64K.\n";
       }
 
       readVector(is, seedVectorSize, seedVector);
 
       is >> trailing;
       if(!is.good() ||
           trailing != std::string("</InitialSeeds>")) {
         throw Exception(errors::Configuration)
           << "File \"" << restoreFileName_
           << "\" is ill-structured or otherwise corrupted.\n"
           << "Cannot read end of InitialSeeds when restoring random engine states.\n";
       }
 
       is >> leading >> stateVectorSize >> trailing;
       if(!is.good() ||
           leading != std::string("<FullStateLength>") ||
           trailing != std::string("</FullStateLength>")) {
         throw Exception(errors::Configuration)
           << "File \"" << restoreFileName_
           << "\" is ill-structured or otherwise corrupted.\n"
           << "Cannot read state vector length when restoring random engine states.\n";
       }
 
       is >> leading;
       if(!is.good() ||
           leading != std::string("<FullState>")) {
         throw Exception(errors::Configuration)
           << "File \"" << restoreFileName_
           << "\" is ill-structured or otherwise corrupted.\n"
           << "Cannot read beginning of FullState when restoring random engine states.\n";
       }
 
       if(stateVectorSize > maxStates) {
         throw Exception(errors::Configuration)
           << "File \"" << restoreFileName_
           << "\" is ill-structured or otherwise corrupted.\n"
           << "The number of states exceeds 64K.\n";
       }
 
       readVector(is, stateVectorSize, stateVector);
 
       is >> trailing;
       if(!is.good() ||
           trailing != std::string("</FullState>")) {
         throw Exception(errors::Configuration)
           << "File \"" << restoreFileName_
           << "\" is ill-structured or otherwise corrupted.\n"
           << "Cannot read end of FullState when restoring random engine states.\n";
       }
 
       if(saveToCache) {
         RandomEngineState randomEngineState;
         randomEngineState.setLabel(moduleLabel);
         std::vector<RandomEngineState>::iterator state =
           std::lower_bound(cache.begin(), cache.end(), randomEngineState);
 
         if(state != cache.end() && moduleLabel == state->getLabel()) {
           if(seedVector.size() != state->getSeed().size() ||
               stateVector.size() != state->getState().size()) {
             throw Exception(errors::Configuration)
               << "File \"" << restoreFileName_
               << "\" is ill-structured or otherwise corrupted.\n"
               << "Vectors containing engine state are the incorrect size for the type of random engine.\n";
           }
           state->setSeed(seedVector);
           state->setState(stateVector);
         }
       }
       return true;
     }

void edm::service::RandomNumberGeneratorService::readEventStatesFromTextFile	(	std::string const &	fileName,
		std::vector< RandomEngineState > &	cache
	)

private

Definition at line 950 of file RandomNumberGeneratorService.cc.

References readStatesFromFile(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by preallocate().

                                                                                                    {
       std::string whichStates("<Event>");
       readStatesFromFile(fileName, cache, whichStates);
     }

void edm::service::RandomNumberGeneratorService::readFromEvent ( Event const & event )

private

Definition at line 717 of file RandomNumberGeneratorService.cc.

References eventCache_, Exception, edm::HandleBase::isValid(), edm::errors::ProductNotFound, restoreStateTag_, and edm::Event::streamID().

Referenced by postEventRead().

                                                                   {
 
       Handle<RandomEngineStates> states;
 
       event.getByLabel(restoreStateTag_, states);
 
       if(!states.isValid()) {
         throw Exception(errors::ProductNotFound)
           << "The RandomNumberGeneratorService is trying to restore\n"
           << "the state of the random engines by reading a product from\n"
           << "the Event with input tag \"" << restoreStateTag_ << "\".\n"
           << "It could not find the product.\n"
           << "Either the product in the Event was dropped or\n"
           << "not produced or the configured input tag is incorrect or there is a bug somewhere\n";
         return;
       }
       states->getRandomEngineStates(eventCache_.at(event.streamID()));
     }

void edm::service::RandomNumberGeneratorService::readFromLuminosityBlock ( LuminosityBlock const & lumi )

private

Definition at line 686 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, Exception, edm::LuminosityBlock::getByLabel(), edm::LuminosityBlock::index(), edm::Service< T >::isAvailable(), edm::HandleBase::isValid(), lumiCache_, edm::InputTag::process(), edm::errors::ProductNotFound, restoreStateBeginLumiTag_, and restoreStateTag_.

Referenced by preBeginLumi().

                                                                                      {
 
       Service<TriggerNamesService> tns;
       if(tns.isAvailable()) {
         if(tns->getProcessName() == restoreStateTag_.process()) {
           throw Exception(errors::Configuration)
             << "In the configuration for the RandomNumberGeneratorService the\n"
             << "restoreStateTag contains the current process which is illegal.\n"
             << "The process name in the replay process should have been changed\n"
             << "to be different than the original process name and the restoreStateTag\n"
             << "should contain either the original process name or an empty process name.\n";
         }
       }
 
       Handle<RandomEngineStates> states;
       lumi.getByLabel(restoreStateBeginLumiTag_, states);
 
       if(!states.isValid()) {
         throw Exception(errors::ProductNotFound)
           << "The RandomNumberGeneratorService is trying to restore\n"
           << "the state of the random engines by reading a product from\n"
           << "the LuminosityBlock with input tag \"" << restoreStateBeginLumiTag_ << "\".\n"
           << "It could not find the product.\n"
           << "Either the product in the LuminosityBlock was dropped or\n"
           << "not produced or the configured input tag is incorrect or there is a bug somewhere\n";
         return;
       }
       states->getRandomEngineStates(lumiCache_.at(lumi.index()));
     }

void edm::service::RandomNumberGeneratorService::readLumiStatesFromTextFile	(	std::string const &	fileName,
		std::vector< RandomEngineState > &	cache
	)

private

Definition at line 957 of file RandomNumberGeneratorService.cc.

References readStatesFromFile(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by preallocate().

                                                                                                   {
       std::string whichStates("<Lumi>");
       readStatesFromFile(fileName, cache, whichStates);
     }

void edm::service::RandomNumberGeneratorService::readStatesFromFile	(	std::string const &	fileName,
		std::vector< RandomEngineState > &	cache,
		std::string const &	whichStates
	)

private

Definition at line 965 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, Exception, recoMuon::in, readEngineState(), restoreFileName_, AlCaHLTBitMon_QueryRunRegistry::string, and RecoTauValidation_cfi::text.

Referenced by readEventStatesFromTextFile(), and readLumiStatesFromTextFile().

                                                                                    {
       std::ifstream inFile;
       inFile.open(fileName.c_str(), std::ifstream::in);
       if(!inFile) {
         throw Exception(errors::Configuration)
           << "Unable to open the file \""
           << fileName << "\" to restore the random engine states.\n";
       }
 
       std::string text;
       inFile >> text;
       if(!inFile.good() || text != std::string("<RandomEngineStates>")) {
         throw Exception(errors::Configuration)
           << "Attempting to read file with random number engine states.\n"
           << "File \"" << restoreFileName_
           << "\" is ill-structured or otherwise corrupted.\n"
           << "Cannot read the file header word.\n";
       }
       bool saveToCache = false;
       while(readEngineState(inFile, cache, whichStates, saveToCache)) {}
     }

void edm::service::RandomNumberGeneratorService::readVector	(	std::istream &	is,
		unsigned	numItems,
		std::vector< std::uint32_t > &	v
	)

private

Definition at line 1138 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, data, Exception, mps_fire::i, and restoreFileName_.

Referenced by readEngineState().

                                                                                                          {
       v.clear();
       v.reserve(numItems);
       std::uint32_t data;
       for(unsigned i = 0; i < numItems; ++i) {
         is >> data;
         if(!is.good()) {
           throw Exception(errors::Configuration)
             << "File \"" << restoreFileName_
             << "\" is ill-structured or otherwise corrupted.\n"
             << "Cannot read vector when restoring random engine states.\n";
         }
         v.push_back(data);
       }
     }

void edm::service::RandomNumberGeneratorService::resetEngineSeeds	(	LabelAndEngine &	labelAndEngine,
		std::string const &	engineName,
		VUint32 const &	seeds,
		std::uint32_t	offset1,
		std::uint32_t	offset2
	)

private

Definition at line 1218 of file RandomNumberGeneratorService.cc.

References edm::service::RandomNumberGeneratorService::LabelAndEngine::engine(), maxSeedHepJames, maxSeedRanecu, maxSeedTRandom3, mod(), edm::service::RandomNumberGeneratorService::LabelAndEngine::setSeed(), and mitigatedMETSequence_cff::U.

Referenced by createEnginesInVector().

                                                                         {
 
       if(engineName == "RanecuEngine") {
         assert(seeds.size() == 2U);
         // Wrap around if the offsets push the seed over the maximum allowed value
         std::uint32_t mod = maxSeedRanecu + 1U;
         offset1 %= mod;
         offset2 %= mod;
         std::uint32_t seed0 = (seeds[0] + offset1) % mod;
         seed0 = (seed0 + offset2) % mod;
         labelAndEngine.setSeed(seed0, 0);
         labelAndEngine.setSeed(seeds[1], 1);
         long int seedL[2];
         seedL[0] = static_cast<long int>(seed0);
         seedL[1] = static_cast<long int>(seeds[1]);
         labelAndEngine.engine()->setSeeds(seedL,0);
       } else {
         assert(seeds.size() == 1U);
 
         if(engineName == "HepJamesRandom" || engineName == "MixMaxRng") {
           // Wrap around if the offsets push the seed over the maximum allowed value
           std::uint32_t mod = maxSeedHepJames + 1U;
           offset1 %= mod;
           offset2 %= mod;
           std::uint32_t seed0 = (seeds[0] + offset1) % mod;
           seed0 = (seed0 + offset2) % mod;
           labelAndEngine.setSeed(seed0, 0);
 
           long int seedL = static_cast<long int>(seed0);
           labelAndEngine.engine()->setSeed(seedL, 0);
         } else {
           assert(engineName == "TRandom3");
           // Wrap around if the offsets push the seed over the maximum allowed value
           // We have to be extra careful with this one because it may also go beyond
           // the values 32 bits can hold
           std::uint32_t max32 = maxSeedTRandom3;
           std::uint32_t seed0 = seeds[0];
           if((max32 - seed0) >= offset1) {
             seed0 += offset1;
           } else {
             seed0 = offset1 - (max32 - seed0) - 1U;
           }
           if((max32 - seed0) >= offset2) {
             seed0 += offset2;
           } else {
             seed0 = offset2 - (max32 - seed0) - 1U;
           }
           labelAndEngine.setSeed(seed0, 0);
 
           long seedL = static_cast<long>(seed0);
 
           // There is a dangerous conversion from std::uint32_t to long
           // that occurs above. In the next 2 lines we check the
           // behavior is what we need for the service to work
           // properly.  This conversion is forced on us by the
           // CLHEP and ROOT interfaces. If the assert ever starts
           // to fail we will have to come up with a way to deal
           // with this.
           std::uint32_t seedu32 = static_cast<std::uint32_t>(seedL);
           assert(seed0 == seedu32);
 
           labelAndEngine.engine()->setSeed(seedL, 0);
         }
       }
     }

void edm::service::RandomNumberGeneratorService::restoreFromCache	(	std::vector< RandomEngineState > const &	cache,
		std::vector< LabelAndEngine > &	engines
	)

private

Definition at line 759 of file RandomNumberGeneratorService.cc.

References checkEngineType(), Exception, AlCaHLTBitMon_QueryRunRegistry::string, edm::errors::Unknown, and heppy_batch::val.

Referenced by postEventRead(), preallocate(), preBeginLumi(), setEventCache(), and setLumiCache().

                                                                                        {
       std::vector<LabelAndEngine>::iterator labelAndEngine = engines.begin();
       for(auto const& cachedState : cache) {
 
         std::string const& engineLabel = cachedState.getLabel();
 
         std::vector<std::uint32_t> const& engineState = cachedState.getState();
         std::vector<unsigned long> engineStateL;
         engineStateL.reserve(engineState.size());
         for(auto const& value : engineState) {
           engineStateL.push_back(static_cast<unsigned long>(value));
         }
 
         std::vector<std::uint32_t> const& engineSeeds = cachedState.getSeed();
         std::vector<long> engineSeedsL;
         engineSeedsL.reserve(engineSeeds.size());
         for(auto const& val : engineSeeds) {
           long seedL = static_cast<long>(val);
           engineSeedsL.push_back(seedL);
 
           // There is a dangerous conversion from std::uint32_t to long
           // that occurs above. In the next 2 lines we check the
           // behavior is what we need for the service to work
           // properly.  This conversion is forced on us by the
           // CLHEP and ROOT interfaces. If the assert ever starts
           // to fail we will have to come up with a way to deal
           // with this.
           std::uint32_t seedu32 = static_cast<std::uint32_t>(seedL);
           assert(val == seedu32);
         }
 
         assert(labelAndEngine != engines.end() && engineLabel == labelAndEngine->label());
         std::shared_ptr<CLHEP::HepRandomEngine> const& engine = labelAndEngine->engine();
 
         // We need to handle each type of engine differently because each
         // has different requirements on the seed or seeds.
         if(engineStateL[0] == CLHEP::engineIDulong<CLHEP::HepJamesRandom>()) {
 
           checkEngineType(engine->name(), std::string("HepJamesRandom"), engineLabel);
 
           // These two lines actually restore the seed and engine state.
           engine->setSeed(engineSeedsL[0], 0);
           engine->get(engineStateL);
 
           labelAndEngine->setSeed(engineSeeds[0], 0);
         } else if(engineStateL[0] == CLHEP::engineIDulong<CLHEP::RanecuEngine>()) {
 
           checkEngineType(engine->name(), std::string("RanecuEngine"), engineLabel);
 
           // This line actually restores the engine state.
           engine->get(engineStateL);
 
           labelAndEngine->setSeed(engineSeeds[0], 0);
           labelAndEngine->setSeed(engineSeeds[1], 1);
         } else if(engineStateL[0] == CLHEP::engineIDulong<CLHEP::MixMaxRng>()) {
 
           checkEngineType(engine->name(), std::string("MixMaxRng"), engineLabel);
 
           // This line actually restores the engine state.
           engine->setSeed(engineSeedsL[0], 0);
           engine->get(engineStateL);
 
           labelAndEngine->setSeed(engineSeeds[0], 0);
         } else if(engineStateL[0] == CLHEP::engineIDulong<TRandomAdaptor>()) {
 
           checkEngineType(engine->name(), std::string("TRandom3"), engineLabel);
 
           // This line actually restores the engine state.
           engine->setSeed(engineSeedsL[0], 0);
           engine->get(engineStateL);
 
           labelAndEngine->setSeed(engineSeeds[0], 0);
         } else {
           // This should not be possible because this code should be able to restore
           // any kind of engine whose state can be saved.
           throw Exception(errors::Unknown)
             << "The RandomNumberGeneratorService is trying to restore the state\n"
                "of the random engines.  The state in the event indicates an engine\n"
                "of an unknown type.  This should not be possible unless you are\n"
                "running with an old code release on a new file that was created\n"
                "with a newer release which had new engine types added.  In this case\n"
                "the only solution is to use a newer release.  In any other case, notify\n"
                "the EDM developers because this should not be possible\n";
         }
         ++labelAndEngine;
       }
     }

void edm::service::RandomNumberGeneratorService::saveStatesToFile	(	std::string const &	fileName,
		StreamID const &	streamID,
		LuminosityBlockIndex const &	lumiIndex
	)

private

Definition at line 870 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, eventCache_, Exception, FrontierConditions_GlobalTag_cff::file, MillePedeFileConverter_cfg::fileName, lumiCache_, nStreams_, MillePedeFileConverter_cfg::out, GetRecoTauVFromDQM_MC_cff::outFile, outFiles_, estimatePileup_makeJSON::trunc, edm::StreamID::value(), and writeStates().

Referenced by postEventRead().

                                                                                           {
 
       std::ofstream& outFile = *outFiles_.at(streamID);
 
       if(!outFile.is_open()) {
         std::stringstream file;
         file << fileName;
         if(nStreams_ > 1) {
           file << "_" << streamID.value();
         }
 
         outFile.open(file.str().c_str(), std::ofstream::out | std::ofstream::trunc);
 
         if(!outFile) {
           throw Exception(errors::Configuration)
             << "Unable to open the file \""
             << file.str() << "\" to save the state of the random engines.\n";
         }
       }
 
       outFile.seekp(0, std::ios_base::beg);
       outFile << "<RandomEngineStates>\n";
 
       outFile << "<Event>\n";
       writeStates(eventCache_.at(streamID), outFile);
       outFile << "</Event>\n";
 
       outFile << "<Lumi>\n";
       writeStates(lumiCache_.at(lumiIndex), outFile);
       outFile << "</Lumi>\n";
 
       outFile << "</RandomEngineStates>\n";
       outFile.flush();
     }

void edm::service::RandomNumberGeneratorService::setEventCache	(	StreamID	iStream,
		std::vector< RandomEngineState > const &	iStates
	)

overridevirtual

Implements edm::RandomNumberGenerator.

Definition at line 500 of file RandomNumberGeneratorService.cc.

References eventCache_, restoreFromCache(), and streamEngines_.

                                                                                                              {
       eventCache_[iStream] = iStates;
       // copy from event cache to engines
       restoreFromCache(eventCache_[iStream], streamEngines_[iStream]);
     }

void edm::service::RandomNumberGeneratorService::setLumiCache	(	LuminosityBlockIndex	iLumi,
		std::vector< RandomEngineState > const &	iStates
	)

overridevirtual

Implements edm::RandomNumberGenerator.

Definition at line 494 of file RandomNumberGeneratorService.cc.

References lumiCache_, lumiEngines_, and restoreFromCache().

                                                                                                                       {
       lumiCache_[iLumi] = iStates;
       // Copy from cache to engine the state for a particular luminosityBlockIndex
       restoreFromCache(lumiCache_[iLumi], lumiEngines_[iLumi]);
     }

void edm::service::RandomNumberGeneratorService::snapShot	(	std::vector< LabelAndEngine > const &	engines,
		std::vector< RandomEngineState > &	cache
	)

private

Definition at line 737 of file RandomNumberGeneratorService.cc.

References label, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by postEventRead(), and preallocate().

                                                                                                                         {
       cache.resize(engines.size());
       std::vector<RandomEngineState>::iterator state = cache.begin();
 
       for(std::vector<LabelAndEngine>::const_iterator iter = engines.begin();
            iter != engines.end();
            ++iter, ++state) {
 
         std::string const& label = iter->label();
         state->setLabel(label);
         state->setSeed(iter->seeds());
 
         std::vector<unsigned long> stateL = iter->engine()->put();
         state->clearStateVector();
         state->reserveStateVector(stateL.size());
         for(auto element : stateL) {
           state->push_back_stateVector(static_cast<std::uint32_t>(element));
         }
       }
     }

void edm::service::RandomNumberGeneratorService::writeStates	(	std::vector< RandomEngineState > const &	v,
		std::ofstream &	outFile
	)

private

Definition at line 908 of file RandomNumberGeneratorService.cc.

References writeVector().

Referenced by saveStatesToFile().

                                                                     {
       for(auto & state : v) {
         std::vector<std::uint32_t> const& seedVector = state.getSeed();
         std::vector<std::uint32_t>::size_type seedVectorLength = seedVector.size();
 
         std::vector<std::uint32_t> const& stateVector = state.getState();
         std::vector<std::uint32_t>::size_type stateVectorLength = stateVector.size();
 
         outFile << "<ModuleLabel>\n" << state.getLabel() << "\n</ModuleLabel>\n";
 
         outFile << "<SeedLength>\n" << seedVectorLength << "\n</SeedLength>\n" ;
         outFile << "<InitialSeeds>\n";
         writeVector(seedVector, outFile);
         outFile << "</InitialSeeds>\n";
         outFile << "<FullStateLength>\n" << stateVectorLength << "\n</FullStateLength>\n";
         outFile << "<FullState>\n";
         writeVector(stateVector, outFile);
         outFile   << "</FullState>\n";
       }
     }

void edm::service::RandomNumberGeneratorService::writeVector	(	VUint32 const &	v,
		std::ofstream &	outFile
	)

private

Definition at line 931 of file RandomNumberGeneratorService.cc.

References mps_fire::i.

Referenced by writeStates().

                                                                     {
       if(v.empty()) return;
       size_t numItems = v.size();
       for(size_t i = 0; i < numItems; ++i)  {
         if(i != 0 && i % 10 == 0) outFile << "\n";
         outFile << std::setw(13) << v[i];
       }
       outFile << "\n";
     }