#include <RandomNumberGeneratorService.h>

Inheritance diagram for edm::service::RandomNumberGeneratorService:

Classes
class	LabelAndEngine

class	ModuleIDToEngine

class	SeedsAndName

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

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

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

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

virtual std::uint32_t	mySeed () const override

virtual void	postEventRead (Event const &event) override

void	postForkReacquireResources (unsigned childIndex, unsigned kMaxChildren)

void	postModuleBeginJob (ModuleDescription const &description)

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

void	postModuleConstruction (ModuleDescription const &description)

void	postModuleEndJob (ModuleDescription const &description)

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 &)

virtual void	preBeginLumi (LuminosityBlock const &lumi) override

void	preModuleBeginJob (ModuleDescription const &description)

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

void	preModuleConstruction (ModuleDescription const &description)

void	preModuleEndJob (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)

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

	RandomNumberGeneratorService (ParameterSet const &pset, ActivityRegistry &activityRegistry)

virtual	~RandomNumberGeneratorService ()

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
unsigned	childIndex_

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

static thread_local std::string	moduleLabel_

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 50 of file RandomNumberGeneratorService.h.

Member Typedef Documentation

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

private

Definition at line 125 of file RandomNumberGeneratorService.h.

Constructor & Destructor Documentation

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

Definition at line 63 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")),
       childIndex_(0U),
       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 2147483647.\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\" and \"TRandom3\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 900000000.\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") {
             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);
 
       activityRegistry.watchPostForkReacquireResources(this, &RandomNumberGeneratorService::postForkReacquireResources);
 
       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);
       }
 
       // The next 5 lines support the mySeed function
       // DELETE THEM when/if that function is deleted.
       activityRegistry.watchPostModuleConstruction(this, &RandomNumberGeneratorService::postModuleConstruction);
       activityRegistry.watchPreModuleBeginJob(this, &RandomNumberGeneratorService::preModuleBeginJob);
       activityRegistry.watchPostModuleBeginJob(this, &RandomNumberGeneratorService::postModuleBeginJob);
       activityRegistry.watchPreModuleEndJob(this, &RandomNumberGeneratorService::preModuleEndJob);
       activityRegistry.watchPostModuleEndJob(this, &RandomNumberGeneratorService::postModuleEndJob);
     }

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

virtual

Definition at line 214 of file RandomNumberGeneratorService.cc.

214 {

215 }

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 877 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::string edm::service::RandomNumberGeneratorService::constructSaveFileName ( ) const

private

Definition at line 973 of file RandomNumberGeneratorService.cc.

References createBeamHaloJobs::directory, newFWLiteAna::fullName, 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::createEnginesInVector	(	std::vector< LabelAndEngine > &	engines,
		unsigned int	seedOffset,
		unsigned int	eventSeedOffset,
		std::vector< ModuleIDToEngine > &	moduleIDVector
	)

private

Definition at line 1186 of file RandomNumberGeneratorService.cc.

References assert(), i, diffTwoXMLs::label, bookConverter::max, mergeVDriftHistosByStation::name, resetEngineSeeds(), seedsAndNameMap_, python.multivaluedict::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 { // 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 336 of file RandomNumberGeneratorService.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addNode(), edm::ParameterSetDescription::addOptionalUntracked(), edm::ParameterSetDescription::addUntracked(), edm::friendlyname::emptyString(), edm::RequireZeroOrMore, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                           {
       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 ) const

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 218 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, Exception, edm::CurrentModuleOnThread::getCurrentModuleOnThread(), edm::ModuleDescription::id(), edm::errors::LogicError, edm::ModuleCallingContext::moduleDescription(), edm::ModuleDescription::moduleLabel(), streamModuleIDToEngine_, filterCSVwithJSON::target, and edm::StreamID::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> const& moduleIDVector = streamModuleIDToEngine_.at(streamID.value());
       ModuleIDToEngine target(nullptr, moduleID);
       std::vector<ModuleIDToEngine>::const_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 ) const

overridevirtual

Use this engine in the global begin luminosity block method.

Implements edm::RandomNumberGenerator.

Definition at line 255 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, Exception, edm::CurrentModuleOnThread::getCurrentModuleOnThread(), edm::ModuleDescription::id(), edm::errors::LogicError, lumiModuleIDToEngine_, edm::ModuleCallingContext::moduleDescription(), edm::ModuleDescription::moduleLabel(), filterCSVwithJSON::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> const& moduleIDVector = lumiModuleIDToEngine_.at(lumiIndex.value());
       ModuleIDToEngine target(nullptr, moduleID);
       std::vector<ModuleIDToEngine>::const_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 612 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 607 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 298 of file RandomNumberGeneratorService.cc.

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

                                                {
       std::string label;
       ModuleCallingContext const* mcc = CurrentModuleOnThread::getCurrentModuleOnThread();
       if(mcc == nullptr) {
         if(!moduleLabel_.empty()) {
           label = moduleLabel_;
         }
         else {
           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";
         }
       } 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 516 of file RandomNumberGeneratorService.cc.

References constructSaveFileName(), eventCache_, newFWLiteAna::fullName, 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::postForkReacquireResources	(	unsigned	childIndex,
		unsigned	kMaxChildren
	)

Definition at line 454 of file RandomNumberGeneratorService.cc.

References assert(), childIndex_, edm::errors::Configuration, gather_cfg::cout, eventSeedOffset_, Exception, i, lumiCache_, lumiEngines_, nStreams_, print(), resetEngineSeeds(), restoreFileName_, saveFileName_, seedsAndNameMap_, snapShot(), streamEngines_, createPayload::suffix, and verbose_.

Referenced by RandomNumberGeneratorService().

                                                                                                        {
       assert(nStreams_ == 1);
       childIndex_ = childIndex;
 
       if(!restoreFileName_.empty()) {
         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 process is configured to fork multiple processes. No forking is\n"
           << "is allowed with this type of replay\n";
       }
 
       if (childIndex_ != 0) {
         std::vector<LabelAndEngine>& engines = streamEngines_[0];
         for(auto& labelAndEngine : engines) {
           std::map<std::string, SeedsAndName>::const_iterator seedsAndName = seedsAndNameMap_.find(labelAndEngine.label());
           assert(seedsAndName != seedsAndNameMap_.end());
           resetEngineSeeds(labelAndEngine,
                            seedsAndName->second.engineName(),
                            seedsAndName->second.seeds(),
                            childIndex,
                            eventSeedOffset_);
         }
       }
       if (kMaxChildren != 0) {
         for(unsigned int i = 0; i < lumiEngines_.size(); ++i) {
           std::vector<LabelAndEngine>& engines = lumiEngines_.at(i);
           for(auto& labelAndEngine : engines) {
             std::map<std::string, SeedsAndName>::const_iterator seedsAndName = seedsAndNameMap_.find(labelAndEngine.label());
             assert(seedsAndName != seedsAndNameMap_.end());
             resetEngineSeeds(labelAndEngine,
                              seedsAndName->second.engineName(),
                              seedsAndName->second.seeds(),
                              kMaxChildren,
                              0);
           }
           snapShot(lumiEngines_[i], lumiCache_[i]);
         }
       }
 
       if(!saveFileName_.empty()) {
         std::ostringstream suffix;
         suffix << "_" << childIndex;
         saveFileName_ += suffix.str();
       }
       if(verbose_) {
         print(std::cout);
       }
     }

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

Definition at line 387 of file RandomNumberGeneratorService.cc.

References moduleLabel_.

Referenced by RandomNumberGeneratorService().

                                                                                          {
       moduleLabel_.clear();
     }

void edm::service::RandomNumberGeneratorService::postModuleBeginStream	(	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::postModuleConstruction ( ModuleDescription const & description )

Definition at line 377 of file RandomNumberGeneratorService.cc.

References moduleLabel_.

Referenced by RandomNumberGeneratorService().

                                                                                              {
       moduleLabel_.clear();
     }

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

Definition at line 397 of file RandomNumberGeneratorService.cc.

References moduleLabel_.

Referenced by RandomNumberGeneratorService().

                                                                                        {
       moduleLabel_.clear();
     }

void edm::service::RandomNumberGeneratorService::postModuleEndStream	(	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::postModuleStreamBeginLumi	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

Definition at line 592 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 572 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 699 of file RandomNumberGeneratorService.cc.

References enableChecking_, edm::service::RandomNumberGeneratorService::LabelAndEngine::engine(), Exception, edm::ModuleDescription::id(), edm::errors::LogicError, edm::ModuleCallingContext::moduleDescription(), edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), edm::StreamContext::streamID(), streamModuleIDToEngine_, filterCSVwithJSON::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> const& moduleIDVector = streamModuleIDToEngine_.at(sc.streamID().value());
         ModuleIDToEngine target(nullptr, moduleID);
         std::vector<ModuleIDToEngine>::const_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 602 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 582 of file RandomNumberGeneratorService.cc.

References postModuleStreamCheck().

Referenced by RandomNumberGeneratorService().

                                                                                                                  {
       postModuleStreamCheck(sc, mcc);
     }

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

Definition at line 402 of file RandomNumberGeneratorService.cc.

References assert(), 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].reset(new std::ofstream);
         }
       }
       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 505 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::preModuleBeginJob ( ModuleDescription const & description )

Definition at line 382 of file RandomNumberGeneratorService.cc.

References edm::ModuleDescription::moduleLabel(), and moduleLabel_.

Referenced by RandomNumberGeneratorService().

                                                                                         {
       moduleLabel_ = description.moduleLabel();
     }

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 547 of file RandomNumberGeneratorService.cc.

References preModuleStreamCheck().

Referenced by RandomNumberGeneratorService().

                                                                                                                {
       preModuleStreamCheck(sc, mcc);
     }

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

Definition at line 364 of file RandomNumberGeneratorService.cc.

References edm::ModuleDescription::id(), edm::ModuleDescription::moduleLabel(), 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());
       }
       // The next line supports the mySeed function
       // DELETE IT when/if that function is deleted.
       moduleLabel_ = description.moduleLabel();
     }

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

Definition at line 392 of file RandomNumberGeneratorService.cc.

References edm::ModuleDescription::moduleLabel(), and moduleLabel_.

Referenced by RandomNumberGeneratorService().

                                                                                       {
       moduleLabel_ = description.moduleLabel();
     }

void edm::service::RandomNumberGeneratorService::preModuleEndStream	(	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::preModuleStreamBeginLumi	(	StreamContext const &	sc,
		ModuleCallingContext const &	mcc
	)

Definition at line 587 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 567 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 683 of file RandomNumberGeneratorService.cc.

References enableChecking_, edm::service::RandomNumberGeneratorService::LabelAndEngine::engine(), edm::ModuleDescription::id(), edm::ModuleCallingContext::moduleDescription(), edm::StreamContext::streamID(), streamModuleIDToEngine_, filterCSVwithJSON::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 597 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 577 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 617 of file RandomNumberGeneratorService.cc.

References childIndex_, enableChecking_, eventSeedOffset_, i, j, relval_steps::k, lumiEngines_, nStreams_, restoreFileName_, restoreStateBeginLumiTag_, restoreStateTag_, saveFileName_, saveFileNameRecorded_, seedsAndNameMap_, streamEngines_, AlCaHLTBitMon_QueryRunRegistry::string, and verbose_.

Referenced by postForkReacquireResources(), and 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 << "    childIndex_ = " << childIndex_ << "\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 {
             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 {
             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 1020 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, Exception, 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 981 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 754 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 723 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 988 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 996 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, Exception, recoMuon::in, readEngineState(), restoreFileName_, AlCaHLTBitMon_QueryRunRegistry::string, and runonSM::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 1169 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, data, Exception, 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 1243 of file RandomNumberGeneratorService.cc.

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

Referenced by createEnginesInVector(), and postForkReacquireResources().

                                                                         {
 
       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") {
           // 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 796 of file RandomNumberGeneratorService.cc.

References assert(), checkEngineType(), Exception, AlCaHLTBitMon_QueryRunRegistry::string, edm::errors::Unknown, and relativeConstraints::value.

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

                                                                                        {
       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<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 898 of file RandomNumberGeneratorService.cc.

References edm::errors::Configuration, eventCache_, Exception, mergeVDriftHistosByStation::file, MillePedeFileConverter_cfg::fileName, lumiCache_, nStreams_, dbtoconf::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::snapShot	(	std::vector< LabelAndEngine > const &	engines,
		std::vector< RandomEngineState > &	cache
	)

private

Definition at line 774 of file RandomNumberGeneratorService.cc.

References diffTwoXMLs::label, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by postEventRead(), postForkReacquireResources(), 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 936 of file RandomNumberGeneratorService.cc.

References writeVector().

Referenced by saveStatesToFile().

                                                                     {
       for(std::vector<RandomEngineState>::const_iterator iter = v.begin(),
                                                           iEnd = v.end();
         iter != iEnd; ++iter) {
 
         std::vector<std::uint32_t> const& seedVector = iter->getSeed();
         std::vector<std::uint32_t>::size_type seedVectorLength = seedVector.size();
 
         std::vector<std::uint32_t> const& stateVector = iter->getState();
         std::vector<std::uint32_t>::size_type stateVectorLength = stateVector.size();
 
         outFile << "<ModuleLabel>\n" << iter->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 962 of file RandomNumberGeneratorService.cc.

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