SeedMaster_test.cc File Reference

Test the SeedMaster object, core of NuRandomService. More...

#include <cstdlib>
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include "cetlib/filepath_maker.h"
#include "fhiclcpp/ParameterSet.h"
#include "fhiclcpp/intermediate_table.h"
#include "fhiclcpp/make_ParameterSet.h"
#include "fhiclcpp/parse.h"
#include "fhiclcpp/exception.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "canvas/Utilities/Exception.h"
#include "nutools/RandomUtils/Providers/SeedMaster.h"

Go to the source code of this file.

Typedefs
using	seed_t = unsigned long
using	SeedMaster_t = rndm::SeedMaster< seed_t >

Functions
seed_t	ObtainSeed (SeedMaster_t &seeds, std::string module_name, std::string instance_name="")
	Returns the seed for the specified module/instance, or 0 on error. More...
fhicl::ParameterSet	GetConfiguration (const fhicl::ParameterSet &full_pset, std::string key)
fhicl::ParameterSet	FindSeedServiceConfiguration (const fhicl::ParameterSet &full_pset, std::string key="services.NuRandomService")
std::vector< fhicl::ParameterSet >	FindModulesConfiguration (const fhicl::ParameterSet &full_pset, const std::vector< std::string > &module_types, std::string base_key="physics.analyzers")
std::string	GetModuleID (fhicl::ParameterSet const &pset)
	Returns a string "ModuleType[ModuleName]" out of specified module config. More...
void	StartMessageFacility (fhicl::ParameterSet const &pset)
int	TestModule (SeedMaster_t &seeds, const fhicl::ParameterSet &pset)
	Tests a "module" with a given configuration. More...
int	main (int argc, const char **argv)

Detailed Description

Test the SeedMaster object, core of NuRandomService.

Author

Gianluca Petrillo (petri.nosp@m.llo@.nosp@m.fnal..nosp@m.gov)

Date

December 3rd, 2014

See also

NuRandomService.h SeedTest01_module.cc

The test runs based on the configuration file specified on the command line.

Usage: SeedMaster_test ConfigFile [ParameterSetPath [ModuleType ...]]

In general, the configuration files good for SeedTest01 module should be good for this one as well (as long as ParameterSetPath is specified as services.NuRandomService).

The configuration is in FHiCL format; no search of the FHiCL file is performed: the path of the configuration file must be available from the current directory (or you can specify it as absolute path).

The optional parameter set path selects which part of the configuration file should be used to configure the SeedMaster. For a typical art configuration, it would be "services.NuRandomService". An empty path (default) uses the whole configuration directly.

For each specified ModuleType, all the art modules with that type are considered as having test module configuration (in a art-like configuration, "physics.analyzers" and "physics.producers").

Definition in file SeedMaster_test.cc.

Typedef Documentation

using seed_t = unsigned long

Definition at line 58 of file SeedMaster_test.cc.

using SeedMaster_t = rndm::SeedMaster<seed_t>

Definition at line 59 of file SeedMaster_test.cc.

Function Documentation

std::vector<fhicl::ParameterSet> FindModulesConfiguration	(	const fhicl::ParameterSet &	full_pset,
		const std::vector< std::string > &	module_types,
		std::string	base_key = "physics.analyzers"
	)

Definition at line 100 of file SeedMaster_test.cc.

  {
  fhicl::ParameterSet base_pset = GetConfiguration(full_pset, base_key);
  
  // if this element has "module_type"
  std::string module_type;
  if (base_pset.get_if_present("module_type", module_type)) {
    // so this is a module configuration;
    // is this module among the ones we are looking for?
    if (std::find(module_types.begin(), module_types.end(), module_type)
      != module_types.end()
      )
      return { base_pset };
    else return {};
  } // if module configuration
  
  // not a module; maybe a module is nested somewhere in?
  std::vector<fhicl::ParameterSet> psets;
  for (std::string pset_key: base_pset.get_pset_names()) {
    std::vector<fhicl::ParameterSet> new_psets = FindModulesConfiguration(
      base_pset.get<fhicl::ParameterSet>(pset_key),
      module_types, ""
      );
    psets.insert(psets.end(), new_psets.begin(), new_psets.end());
  } // for
  return psets;
} // FindModulesConfiguration()

fhicl::ParameterSet FindSeedServiceConfiguration ( const fhicl::ParameterSet &  full_pset, std::string  key = "services.NuRandomService"  )

inline

Definition at line 92 of file SeedMaster_test.cc.

  {
  return GetConfiguration(full_pset, key);
} // FindSeedServiceConfiguration()

fhicl::ParameterSet GetConfiguration ( const fhicl::ParameterSet &  full_pset, std::string  key  )

inline

Definition at line 86 of file SeedMaster_test.cc.

{
  return key.empty()? full_pset: full_pset.get<fhicl::ParameterSet>(key);
} // GetConfiguration()

std::string GetModuleID ( fhicl::ParameterSet const &  pset )

inline

Returns a string "ModuleType[ModuleName]" out of specified module config.

Definition at line 133 of file SeedMaster_test.cc.

                                                            {
  return pset.get<std::string>("module_type", "Unknown")
    + "[" + pset.get<std::string>("module_name", "unknown") + "]";
} // GetModuleID()

int main	(	int	argc,
		const char **	argv
	)

Definition at line 253 of file SeedMaster_test.cc.

                                      {
  
  //****************************************************************************
  //*** parse command line options
  //***
  std::string config_path;
  std::string parameter_set_name;
  std::vector<std::string> module_types{ "SeedTestPolicy" };
  
  int iParam = 0;
  // configuration file path (mandatory)
  if (++iParam < argc) {
    config_path = argv[iParam];
  }
  else {
    std::cerr
      << "SeedMaster_test: please specify a configuration file." << std::endl;
    return 1;
  }
  
  // configuration key for the SeedMaster (optional)
  if (++iParam < argc) {
    parameter_set_name = argv[iParam];
  }
  
  // module types for modules autodetection (optional)
  if (++iParam < argc) {
    module_types.assign(argv + iParam, argv + argc);
  }
  
  
  //****************************************************************************
  //*** read the configuration from the file specified on the command line
  //***
  // simple file lookup policy: assume the file name specification is complete
  cet::filepath_maker policy;

  // parse a configuration file; obtain intermediate form
  fhicl::intermediate_table table;
  fhicl::parse_document(config_path, policy, table);
  
  // translate into a parameter set
  fhicl::ParameterSet global_pset;
  fhicl::make_ParameterSet(table, global_pset);
  
  // initialize the message facility
  StartMessageFacility(global_pset);
  mf::SetContextSinglet("main");
  
  // read the configuration of the seed service
  fhicl::ParameterSet pset;
  try {
    pset = FindSeedServiceConfiguration(global_pset, parameter_set_name);
  }
  catch (...) {
    mf::LogError("SeedMaster_t")
      << "Failed to read the '" << parameter_set_name
      << "' parameters set from configuration file '" << config_path << "'";
    throw;
  }
  
  mf::LogInfo("SeedMaster_test") << "Parameters from '" << config_path << "':\n"
    << pset.to_indented_string();
  
  // look for test modules
  std::string module_base_key = "physics.analyzers";
  std::vector<fhicl::ParameterSet> module_psets
    = FindModulesConfiguration(global_pset, module_types, module_base_key);
  if (module_psets.empty()) {
    mf::LogError("SeedMaster_test")
      << "could not find any suitable module configuration in '"
      << module_base_key << "' of '" << config_path
      << "'";
    return 1;
  } // if no modules

  { // anonymous block
    mf::LogInfo log("SeedMaster_test");
    log << "Found configurations for " << module_psets.size() << " modules.";
    for (const fhicl::ParameterSet& pset: module_psets) {
      std::string module_id = GetModuleID(pset);
      log << '\n' << "*** " << module_id << " ***"
        << std::string(72 - 8 - module_id.length(), '*')
        << '\n' << pset.to_indented_string(1);
    } // for
    log << '\n' << std::string(72, '*');
  } // end anonymous block
  
  bool endOfJobSummary = pset.get<bool>("endOfJobSummary", false);
  
  //****************************************************************************
  //*** perform the tests...
  //***
  // create a new SeedMaster with the specified parameters set
  std::unique_ptr<SeedMaster_t> pSeeds;
  try {
    pSeeds.reset(new SeedMaster_t(pset));
  }
  catch (const art::Exception& e) {
    mf::LogError("SeedMaster_test")
      << "Exception caught while initializing SeedMaster:\n"
      << e.what();
    return 1;
  }
  catch (const fhicl::exception& e) {
    mf::LogError("SeedMaster_test")
      << "FHiCL exception caught while initializing SeedMaster:\n"
      << e.what();
    return 1;
  }
  
  unsigned int nErrors = 0;
  for (const fhicl::ParameterSet& module_pset: module_psets) {
    try {
      nErrors += TestModule(*pSeeds, module_pset);
    }
    catch(const art::Exception& e) {
      mf::LogError("SeedMaster_test")
        << "Exception caught while testing module " << GetModuleID(module_pset)
        << ":\n"
        << e.what();
      ++nErrors;
    }
  } // for
  mf::SetContextSinglet("main");
  
  
  //****************************************************************************
  //*** print the outcome and go
  //***
  
  if (endOfJobSummary) pSeeds->print();
  
  if (nErrors > 0) {
    mf::LogError("SeedMaster_test")
      << "Test terminated with " << nErrors << " errors.";
    return nErrors;
  }
  mf::LogInfo("SeedMaster_test") << "Test successful.";
  return 0;
} // main()

seed_t ObtainSeed	(	SeedMaster_t &	seeds,
		std::string	module_name,
		std::string	instance_name = ""
	)

Returns the seed for the specified module/instance, or 0 on error.

Definition at line 63 of file SeedMaster_test.cc.

{
  // Returns the seed for the specified engine instance, or 0 in case of
  // configuration error (in which case, an error counter is increased)
  try {
    return seeds.getSeed(instance_name.empty()?
      SeedMaster_t::EngineId(module_name):
      SeedMaster_t::EngineId(module_name, instance_name)
      );
  }
  catch(art::Exception& e) {
    mf::LogError("SeedMaster") << "Caught an exception while asking seed for '"
      << module_name << "." << instance_name << ":\n"
      << e.what();
    return 0;
  }
} // ObtainSeed()

void StartMessageFacility

(

fhicl::ParameterSet const &

pset

)

Definition at line 142 of file SeedMaster_test.cc.

                                                         {
  fhicl::ParameterSet mf_pset;
  if (!pset.get_if_present("services.message", mf_pset)) {
    // a destination which will react to messages more severe than DEBUG
    std::string MessageFacilityConfiguration = R"(
    destinations : {
      stdout: {
        type:      cout
        threshold: INFO
        categories: {
          default: {
            limit : 10
          }
        } // categories
      } // stdout
    } // destinations
    statistics: cout
    )";
    fhicl::make_ParameterSet(MessageFacilityConfiguration, mf_pset);
    std::cout << "Using default message facility configuration:\n"
      << mf_pset.to_indented_string(1) << std::endl;
  } // if no configuration is available
  
  mf::StartMessageFacility(mf_pset);
  mf::SetApplicationName("SeedMaster_test");
  mf::SetContextIteration("Initialization");
  mf::LogInfo("MessageFacility") << "MessageFacility started.";
} // StartMessageFacility()

int TestModule	(	SeedMaster_t &	seeds,
		const fhicl::ParameterSet &	pset
	)

Tests a "module" with a given configuration.

Definition at line 177 of file SeedMaster_test.cc.

                                                                   {
  
  mf::SetContextSinglet("TestModule");
  
  using seed_t = SeedMaster_t::seed_t;
  
  std::string module_name
    = pset.get<std::string>("module_name", "unknown");
  std::string module_id = GetModuleID(pset);
  
  // read the instance 
  std::vector<std::string> instance_names;
  pset.get_if_present("instanceNames", instance_names);
  unsigned int nExpectedErrors = pset.get<unsigned int>("expectedErrors", 0);
  
  unsigned int nErrors = 0;
  if (instance_names.empty()) {
    instance_names.push_back("");
    mf::LogInfo("SeedMaster_test") << "Added a default engine instance.";
  }  
  mf::LogVerbatim("SeedMaster_test")
    << module_id << " has " << instance_names.size() << " seed instances:";
  
  // seed test: do we successfully get seeds?
  std::vector<seed_t> our_seeds;
  for (std::string instance_name: instance_names) {
    seed_t seed = ObtainSeed(seeds, module_name, instance_name);
    mf::LogVerbatim("SeedMaster_test")
      << "Seed for '" << instance_name << "' is: " << seed;
    if (seed == 0) {
      MF_LOG_ERROR(module_id)
        << "instance " << instance_name << " got seed 0!";
      if (++nErrors <= nExpectedErrors) {
        mf::LogProblem(module_id) << "  (error #" << nErrors
          << ", " << nExpectedErrors << " expected)";
      }
    }
    our_seeds.push_back(seed);
  } // for declaration loop
  
  // consistency test: are they still the same?
  std::vector<seed_t>::const_iterator iOldSeed = our_seeds.begin();
  for (std::string instance_name: instance_names) {
    seed_t seed = ObtainSeed(seeds, module_name, instance_name);
    mf::LogVerbatim("SeedMaster_test")
      << "Seed for '" << instance_name << "' is: " << seed << " (second query)";
    if (seed != *iOldSeed) {
      MF_LOG_ERROR(module_id)
        << "seed has changed for instance "
        << instance_name << ": " << *iOldSeed << " => " << seed;
      if (++nErrors <= nExpectedErrors) {
        mf::LogProblem(module_id) << " error " << nErrors
          << ", " << nExpectedErrors << " expected";
      }
    } // if different from before
    if (*iOldSeed == 0) {
      MF_LOG_ERROR(module_id)
        << "instance " << instance_name << " got seed 0!";
      if (++nErrors <= nExpectedErrors) {
        mf::LogProblem(module_id) << "  (error #" << nErrors
          << ", " << nExpectedErrors << " expected)";
      }
    } // if seed is 0
    ++iOldSeed;
  } // for consistency check
  
  // as many errors as expected, balance is even
  return (nErrors > nExpectedErrors)?
    nErrors - nExpectedErrors: nExpectedErrors - nErrors;
} // TestModule()