rndm::details Namespace Reference

Classes
class	AutoIncrementPolicy
	Implementation of the "autoIncrement" policy. More...
class	CheckedRangePolicy
	Range-checked policy (abstract) More...
class	LinearMappingPolicy
	Implementation of the "linearMapping" policy. More...
class	PerEventPolicy
	Implementation of the "perEvent" policy. More...
class	PerInstancePolicy
	Base class for policies reacting at engine instance level. More...
struct	PolicyStruct_t
class	PredefinedOffsetPolicy
	Implementation of the "preDefinedOffset" policy. More...
class	PredefinedSeedPolicy
	Implementation of the "preDefinedSeed" policy. More...
class	RandomPolicy
	Implementation of the "random" policy. More...
class	RandomSeedPolicyBase
	Interface for a policy implementation. More...
class	RangeCheckHelper
	Helper class to support range checking. More...
class	ValidSeed
	Class storing a seed in the valid range. More...

Enumerations
enum	Policy : unsigned { Policy::NURANDOM_SEED_SERVICE_POLICY, Policy::NURANDOM_SEED_SERVICE_POLICIES }
	Enumeration of all supported random seed policies. More...

Functions
template<typename SEED >
PolicyStruct_t< SEED >	makeRandomSeedPolicy (fhicl::ParameterSet const &config)
	Constructs and returns a RandomSeedPolicyBase based on config. More...
std::vector< std::string > const &	policyNames ()
	Returns a list of names of policies, in the same order as Policy enum. More...
std::string const &	policyName (Policy policy)
	Returns the name of the specified policy. More...
Policy	policyFromName (std::string const &name)
	Returns the policy with the specified name. More...

Enumeration Type Documentation

enum rndm::details::Policy : unsigned

strong

Enumeration of all supported random seed policies.

Enumerator
NURANDOM_SEED_SERVICE_POLICY
NURANDOM_SEED_SERVICE_POLICIES

Definition at line 38 of file PolicyNames.h.

                   : unsigned {
    #define NURANDOM_SEED_SERVICE_POLICY(x) x,
    NURANDOM_SEED_SERVICE_POLICIES
    #undef NURANDOM_SEED_SERVICE_POLICY
  };

Function Documentation

template<typename SEED >

PolicyStruct_t<SEED> rndm::details::makeRandomSeedPolicy

(

fhicl::ParameterSet const &

config

)

Constructs and returns a RandomSeedPolicyBase based on config.

Template Parameters

SEED	the type of seed RandomSeedPolicyBase is serving

Parameters

config

configuration of the policy object

Returns

a new RandomSeedPolicyBase object

The policy class is created according to the parameters in the specified config parameter set. The type of policy is determined by the "policy" key in that parameter set.

Definition at line 63 of file PolicyFactory.h.

References fhicl::ParameterSet::get(), rndm::details::PolicyStruct_t< SEED >::policy, policyFromName(), and policyName().

                                                                             {
    std::string const& policyName = config.get<std::string>("policy");
    
    // Throws if policy is not recognized.
    Policy const policy = policyFromName(policyName);
    
    switch (policy) {
      case Policy::autoIncrement:
        return { policy, std::make_unique<AutoIncrementPolicy<SEED>>(config) };
      case Policy::linearMapping:
        return { policy, std::make_unique<LinearMappingPolicy<SEED>>(config) };
      case Policy::preDefinedOffset:
        return { policy, std::make_unique<PredefinedOffsetPolicy<SEED>>(config) };
      case Policy::preDefinedSeed:
        return { policy, std::make_unique<PredefinedSeedPolicy<SEED>>(config) };
      case Policy::random:
        return { policy, std::make_unique<RandomPolicy<SEED>>(config) };
      case Policy::perEvent:
        return { policy, std::make_unique<PerEventPolicy<SEED>>(config) };
      case Policy::unDefined:
      default:
        // this should have been prevented by an exception by `policyFromName()`
        throw cet::exception("rndm::details::makeRandomSeedPolicy")
          << "Internal error: unknown policy '" << policyName << "'\n";
    } // switch
    
  } // rndm::details::makeRandomSeedPolicy()

Policy rndm::details::policyFromName

(

std::string const &

name

)

Returns the policy with the specified name.

Parameters

name	name of the desired policy

Returns

enumerator value matching the policy with the specified name

Exceptions

cet::exception

(category: rndm::details::policyFromName) if the name is unknown or if it matches Policy::unDefined

The policy placeholder unDefined is not accepted by this function and treated as a non-existing policy.

Definition at line 67 of file PolicyNames.cxx.

References util::begin(), e, util::end(), and policyNames().

Referenced by makeRandomSeedPolicy(), and rndm::SeedMaster< SEED >::setPolicy().

                                                     {
    
    auto const& names = policyNames();
    assert(!names.empty());
    auto const nbegin { begin(names) }, nend { end(names) };
    
    auto const iter = std::find(nbegin, nend, policyName);
    
    Policy const policy = (iter == nend)
      ? Policy::unDefined
      : static_cast<Policy>(std::distance(begin(names), iter))
      ;
    
    if (policy != Policy::unDefined) return policy;
    
    // the first policy, `unDefined`, is deliberately omitted from this message
    cet::exception e { "rndm::details::policyFromName" };
    e << "rndm::details::policyFromName(\"" << policyName
      << "\"): unrecognized policy.\nKnown policies are: ";
    auto iName = nbegin;
    while (++iName != nend) e << " '" << (*iName) << '\'';
    throw e << ".\n";
    
  } // policyFromName()

std::string const & rndm::details::policyName

(

Policy

policy

)

Returns the name of the specified policy.

Exceptions

cet::exception

(category: rndm::details::policyName) if the name is unknown

Definition at line 56 of file PolicyNames.cxx.

References policyNames().

Referenced by makeRandomSeedPolicy(), and rndm::details::PerEventPolicy< SEED >::print().

                                             {
    std::size_t const index { static_cast<unsigned>(policy) };
    if (index < policyNames().size()) return policyNames()[index];
    
    throw cet::exception("rndm::details::policyName")
      << "Invalid policy (index #" << index << ")\n";
    
  } // policyName()

std::vector< std::string > const & rndm::details::policyNames

(

)

Returns a list of names of policies, in the same order as Policy enum.

Definition at line 52 of file PolicyNames.cxx.

Referenced by policyFromName(), policyName(), and rndm::SeedMaster< SEED >::policyNames().

{ return ::PolicyNames; }