Test module for NuRandomService. More...

Inheritance diagram for testing::SeedTestPolicy:

Public Member Functions
	SeedTestPolicy (fhicl::ParameterSet const &pset)

virtual void	analyze (art::Event const &event) override

virtual void	endJob () override

Public Member Functions inherited from art::EDAnalyzer
	EDAnalyzer (fhicl::ParameterSet const &pset)

template<typename Config >
	EDAnalyzer (Table< Config > const &config)

std::string	workerType () const

Public Member Functions inherited from art::detail::Analyzer
virtual	~Analyzer () noexcept

	Analyzer (fhicl::ParameterSet const &pset)

template<typename Config >
	Analyzer (Table< Config > const &config)

void	doBeginJob ()

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)

Public Member Functions inherited from art::Observer
	~Observer () noexcept

	Observer (Observer const &)=delete

	Observer (Observer &&)=delete

Observer &	operator= (Observer const &)=delete

Observer &	operator= (Observer &&)=delete

void	registerProducts (ProductDescriptions &, ModuleDescription const &)

void	fillDescriptions (ModuleDescription const &)

std::string const &	processName () const

bool	wantAllEvents () const

bool	wantEvent (Event const &e)

fhicl::ParameterSetID	selectorConfig () const

Handle< TriggerResults >	getTriggerResults (Event const &e) const

Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept

	ModuleBase ()

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const

void	sortConsumables (std::string const &current_process_name)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Private Types
using	seed_t = testing::NuRandomService::seed_t

Private Member Functions
bool	isLocalEngine (size_t iEngine) const
	Returns whether the engine associated with the specified index is local. More...

seed_t	verifySeed (CLHEP::HepRandomEngine &, std::string const &instanceName)

seed_t	obtainSeed (std::string instanceName="")

bool	handleSeedServiceException (art::Exception &e)
	Returns whether e is an exception we can handle (and, if so, it handles) More...

Private Attributes
std::vector< std::string >	instanceNames

std::map< std::string, seed_t >	startSeeds
	seeds after the constructor More...

unsigned int	nExpectedErrors
	number of expected errors More...

bool	useGenerators
	instanciate and use random number generators More...

bool	perEventSeeds
	whether we expect different seeds on each event More...

std::string const	moduleLabel
	configured module label More...

unsigned int	nErrors = 0
	Number of errors detected so far. More...

std::unique_ptr< CLHEP::HepRandomEngine >	localEngine
	self-managed More...

std::map< std::string, CLHEP::HepRandomEngine * >	engines

Additional Inherited Members
Public Types inherited from art::EDAnalyzer
using	WorkerType = WorkerT< EDAnalyzer >

using	ModuleType = EDAnalyzer

Protected Member Functions inherited from art::Observer
	Observer (fhicl::ParameterSet const &config)

	Observer (std::vector< std::string > const &paths, fhicl::ParameterSet const &config)

detail::ProcessAndEventSelectors &	processAndEventSelectors ()

Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Detailed Description

Test module for NuRandomService.

The test writes on screen the random seeds it gets.

Note that the test does not actually get any random number, unless the useGenerators option is turned on.

Configuration parameters:

instanceNames (string list): use one random number generator for each instance name here specified; if not specified, a single default instance is used
expectedErrors (unsigned integer, default: 0): expect this number of errors from NuRandomService, and throw an exception if we get a different number
useGenerators (boolean, default: true): uses art RandomGeneratorService with the seeds from NuRandomService
perEventSeeds (boolean, default: false): set it to true if the selected policy gives per-event seeds; in this case, the check of seed always being the same is skipped

Definition at line 65 of file SeedTestPolicy_module.cc.

Member Typedef Documentation

using testing::SeedTestPolicy::seed_t = testing::NuRandomService::seed_t

private

Definition at line 76 of file SeedTestPolicy_module.cc.

Constructor & Destructor Documentation

testing::SeedTestPolicy::SeedTestPolicy ( fhicl::ParameterSet const & pset )

explicit

Definition at line 110 of file SeedTestPolicy_module.cc.

   : art::EDAnalyzer(pset)
   , instanceNames  (pset.get<std::vector<std::string>>("instanceNames", {}))
   , nExpectedErrors(pset.get<unsigned int>            ("expectedErrors", 0U))
   , useGenerators  (pset.get<bool>                    ("useGenerators", true))
   , perEventSeeds  (pset.get<bool>                    ("perEventSeeds", false))
   , moduleLabel    (pset.get<std::string>             ("module_label"))
 {
 
   //
   // print some configuration information
   //
   { // anonymous block
     mf::LogInfo log("SeedTestPolicy");
     log << "Construct SeedTestPolicy with "
         << instanceNames.size() <<  " engine instances:";
     for (auto const& instanceName: instanceNames)
       log << " " << instanceName;
 
   } // anonymous block
 
   auto* Seeds = &*(art::ServiceHandle<rndm::NuRandomService>());
 
   // by default, have at least one, default engine instance
   if (instanceNames.empty()) instanceNames.push_back("");
 
   mf::LogInfo log("SeedTestPolicy"); // cumulative log
 
   //
   // register all the engines, and store their seeds
   //
   for (std::string const& instanceName: instanceNames) {
     seed_t const seed = obtainSeed(instanceName);
     log << "\nSeed for '" << instanceName << "' is: " << seed;
     startSeeds.emplace(instanceName, seed);
   } // for first loop (declaration)
 
 
   //
   // verify the seed of each instance
   //
   for (size_t iEngine = 0; iEngine < instanceNames.size(); ++iEngine) {
     std::string const& instanceName = instanceNames[iEngine];
 
     // This involved condition tree ensures that SeedMaster is queried
     // for a seed exactly once per instance, no matter what.
     // This is relevant for the error count.
     // Out of it, a seed is returned.
     seed_t seed = rndm::NuRandomService::InvalidSeed;
     if (isLocalEngine(iEngine)) {
       if (useGenerators) {
         localEngine = std::make_unique<CLHEP::HepJamesRandom>();
         engines.emplace(instanceName, localEngine.get());
         try {
           seed = Seeds->defineEngine(*localEngine, instanceName);
         }
         catch(art::Exception& e) {
           if (!handleSeedServiceException(e)) throw;
         }
         mf::LogInfo("SeedTestConstruct")
           << "Engine instance '" << instanceName
           << "' will be owned by the test module.";
       } // if use generators
       else seed = obtainSeed(instanceName);
     } // if local
     else { // if managed by art
       seed = obtainSeed(instanceName);
       if (useGenerators) {
         auto& engine = createEngine(seed, "HepJamesRandom", instanceName);
         // registration still matters for per-event policies
         Seeds->defineEngine(engine, instanceName);
         verifySeed(engine, instanceName);
         engines.emplace(instanceName, &engine);
       }
     } // if ... else
 
     // check that the seed returned by the service is still the same
     seed_t const expectedSeed = startSeeds.at(instanceName);
     if (seed != expectedSeed) {
       throw art::Exception(art::errors::LogicError)
         << "NuRandomService returned different seed values for engine instance '"
         << instanceName << "': first " << expectedSeed << ", now " << seed
         << "\n";
     } // if unexpected seed
   } // for second loop
 
   //
   // An engine with the following label has already been registered
   // (it's the one managed by RandomGeneratorService).
   // Registering another should raise an exception
   // (incidentally, if useGenerators is false we are trying to register nullptr)
   //
   bool bBug = false;
   try {
     Seeds->declareEngine(instanceNames.front());
     bBug = true;
   }
   catch(std::exception const& e) {
     if (!testing::NuRandomService::isSeedServiceException(e)) throw;
   }
   if (bBug) {
     throw art::Exception(art::errors::LogicError)
       << "Registration of local engine with duplicate label"
       " did not throw an exception";
   }
 
 } // testing::SeedTestPolicy::SeedTestPolicy()

Member Function Documentation

void testing::SeedTestPolicy::analyze ( art::Event const & event )

overridevirtual

Implements art::EDAnalyzer.

Definition at line 220 of file SeedTestPolicy_module.cc.

                                                          {
 
   mf::LogVerbatim("SeedTestPolicy")
     << "SeedTestPolicy::analyze() " << event.id() << " with "
     << instanceNames.size() << " random engines";
 
   if (useGenerators) {
     for (auto const& instanceName : instanceNames) {
       //
       // collect information and resources
       //
       seed_t const startSeed = startSeeds.at(instanceName);
       CLHEP::HepRandomEngine& engine = *engines.at(instanceName);
 
       //
       // check seed (if per event, it should be the opposite)
       //
       seed_t const actualSeed = testing::NuRandomService::readSeed(engine);
       if (perEventSeeds) {
         if (actualSeed == startSeed) {
           // this has a ridiculously low chance of begin fortuitous
           throw art::Exception(art::errors::LogicError)
             << "per event seed " << actualSeed << " of engine '" << instanceName
             << "' is the same as at beginning!\n";
         }
       }
       else {
         if (actualSeed != startSeed) {
           throw art::Exception(art::errors::LogicError)
             << "expected seed " << startSeed << " for engine '" << instanceName
             << "', got " << actualSeed << " instead!\n";
         }
       }
 
       //
       // print character statistics
       //
       mf::LogVerbatim("SeedTestPolicy")
         << std::setw(12) << (instanceName.empty()? "<default>": instanceName)
         << ": " << testing::NuRandomService::CreateCharacter(engine)
         << "   (seed: " << actualSeed << ")";
 
     } // for
   } // if use generators
 
 } // testing::SeedTestPolicy::analyze()

void testing::SeedTestPolicy::endJob ( )

overridevirtual

Reimplemented from art::EDAnalyzer.

Definition at line 270 of file SeedTestPolicy_module.cc.

 {
   // if we have an unexpected amount of errors, bail out
   if (nExpectedErrors != nErrors) {
     art::Exception e(art::errors::Configuration);
     e << "SeedTestPolicy: detected " << nErrors << " errors";
     if (nExpectedErrors) e << ", " << nExpectedErrors << " expected";
     throw e << "!\n";
   }
 } // testing::SeedTestPolicy::endJob()

bool testing::SeedTestPolicy::handleSeedServiceException ( art::Exception & e )

private

Returns whether e is an exception we can handle (and, if so, it handles)

Definition at line 310 of file SeedTestPolicy_module.cc.

 {
   if (!testing::NuRandomService::isSeedServiceException(e)) return false;
 
   ++nErrors;
   mf::LogError log("SeedTest01");
   log << "Detected";
   if (nErrors > nExpectedErrors) log << " UNEXPECTED";
   log << " error #" << nErrors << ":\n" << e << "\n";
   return true;
 } // testing::SeedTestPolicy::handleSeedServiceException()

bool testing::SeedTestPolicy::isLocalEngine ( size_t iEngine ) const

private

Returns whether the engine associated with the specified index is local.

Definition at line 323 of file SeedTestPolicy_module.cc.

                                                         {
   return (i == 0) && (instanceNames.size() != 1);
 } // testing::SeedTestPolicy::isLocalEngine()

testing::SeedTestPolicy::seed_t testing::SeedTestPolicy::obtainSeed ( std::string instanceName = "" )

private

Definition at line 285 of file SeedTestPolicy_module.cc.

 {
   // Returns the seed for the specified engine instance, or 0 in case of
   // configuration error (in which case, an error counter is increased)
   seed_t seed = rndm::NuRandomService::InvalidSeed;
   try {
     art::ServiceHandle<rndm::NuRandomService> seeds;
     // currently (v0_00_03), the two calls are actually equivalent
     seed
       = instanceName.empty()? seeds->getSeed(): seeds->getSeed(instanceName);
   }
   catch(art::Exception& e) {
     if (!testing::NuRandomService::isSeedServiceException(e)) throw;
 
     ++nErrors;
     mf::LogError log("SeedTestPolicy");
     log << "Detected";
     if (nErrors > nExpectedErrors) log << " UNEXPECTED";
     log << " error #" << nErrors << ":\n" << e;
   }
   return seed;
 } // testing::SeedTestPolicy::obtainSeed()

testing::SeedTestPolicy::seed_t testing::SeedTestPolicy::verifySeed	(	CLHEP::HepRandomEngine &	engine,
		std::string const &	instanceName
	)

private

Definition at line 329 of file SeedTestPolicy_module.cc.

 {
   seed_t const actualSeed = testing::NuRandomService::readSeed(engine);
   seed_t const expectedSeed = startSeeds.at(instanceName);
   // if the expected seed is invalid, we are not even sure it was ever set;
   // the engine is in an invalid state and that's it
   if (!rndm::NuRandomService::isSeedValid(expectedSeed)) return actualSeed;
 
   if (actualSeed != expectedSeed) {
     throw art::Exception(art::errors::LogicError)
       << "expected seed " << expectedSeed << " for engine '" << instanceName
       << "', got " << actualSeed << " instead!";
   }
   return actualSeed;
 } // testing::SeedTestPolicy::verifySeed()

Member Data Documentation

std::map<std::string, CLHEP::HepRandomEngine*> testing::SeedTestPolicy::engines

private

Definition at line 88 of file SeedTestPolicy_module.cc.

std::vector<std::string> testing::SeedTestPolicy::instanceNames

private

Definition at line 78 of file SeedTestPolicy_module.cc.

std::unique_ptr<CLHEP::HepRandomEngine> testing::SeedTestPolicy::localEngine

private

self-managed

Definition at line 87 of file SeedTestPolicy_module.cc.

std::string const testing::SeedTestPolicy::moduleLabel

private

configured module label

Definition at line 83 of file SeedTestPolicy_module.cc.

unsigned int testing::SeedTestPolicy::nErrors = 0

private

Number of errors detected so far.

Definition at line 85 of file SeedTestPolicy_module.cc.

unsigned int testing::SeedTestPolicy::nExpectedErrors

private

number of expected errors

Definition at line 80 of file SeedTestPolicy_module.cc.

bool testing::SeedTestPolicy::perEventSeeds

private

whether we expect different seeds on each event

Definition at line 82 of file SeedTestPolicy_module.cc.

std::map<std::string, seed_t> testing::SeedTestPolicy::startSeeds

private

seeds after the constructor

Definition at line 79 of file SeedTestPolicy_module.cc.

bool testing::SeedTestPolicy::useGenerators

private

instanciate and use random number generators

Definition at line 81 of file SeedTestPolicy_module.cc.

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

nutools/old/test/RandomUtils/SeedTestPolicy_module.cc

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation