Test service registering its own ßs. More...

#include <GlobalEngineUserTestService.h>

Public Member Functions
	GlobalEngineUserTestService (fhicl::ParameterSet const &pset, art::ActivityRegistry &reg)

Private Member Functions
void	CheckAllSeeds () const
	Checks all engines by CheckSeed() calls. More...

void	preModuleConstruction (art::ModuleDescription const &)

void	postModuleConstruction (art::ModuleDescription const &)

void	preModuleBeginRun (art::ModuleContext const &)

void	postModuleBeginRun (art::ModuleContext const &)

void	preProcessEvent (art::Event const &evt, art::ScheduleContext)

void	preModule (art::ModuleContext const &)

void	postModule (art::ModuleContext const &)

void	postProcessEvent (art::Event const &, art::ScheduleContext)

void	preModuleEndJob (art::ModuleDescription const &)

void	postModuleEndJob (art::ModuleDescription const &)

Static Private Member Functions
static void	CheckSeed (TRandom const &engine)
	Throws an exception if the seed is not expected. More...

Private Attributes
std::vector< std::string >	instanceNames
	name of engine instances More...

bool	perEventSeeds
	whether to skip seed check in constructor More...

std::vector< std::unique_ptr< TRandom > >	engines
	our random generator engines More...

Static Private Attributes
static const std::string	GlobalInstanceName { "GlobalEngineUserServiceEngine" }
	Name used for the global engine instance. More...

Detailed Description

Test service registering its own ßs.

The service owns all its engines and is asks NuRandomService for their seeds. NuRandomService will use global identifiers for them, that is identifiers not bound to the art execution context (that is, not bound to a specific module).

Configuration parameters

instances (list of strings, default: empty): list of names of the engines this service is going to own; if it results in an empty list, a single instance will be created.
perEventSeeds (boolean, default: false): don't check that seeds match expectations on construction; this is needed in per-event policies where the seed is not known until the events are available

Definition at line 60 of file GlobalEngineUserTestService.h.

Constructor & Destructor Documentation

testing::GlobalEngineUserTestService::GlobalEngineUserTestService	(	fhicl::ParameterSet const &	pset,
		art::ActivityRegistry &	reg
	)

Definition at line 36 of file GlobalEngineUserTestService_service.cc.

   : instanceNames       (pset.get<std::vector<std::string>>("instances", {}))
   , perEventSeeds       (pset.get<bool>                    ("perEventSeeds", false))
 {
   
   //
   // input parameters check
   //
   if (instanceNames.empty()) {
     instanceNames.push_back("GlobalEngineUserTestService");
     mf::LogInfo("GlobalEngineUserTestService")
       << "Using a default engine instance name: '" << instanceNames.back()
       << "'";
   }
   
   //
   // create all our engines (uninteresting temporary seeds are set)
   //
   for (std::string instanceName: instanceNames) {
     engines.emplace_back(std::make_unique<TRandom3>());
     engines.back()->SetTitle(instanceName.c_str());
   } // for
 
   //
   // register all the engines
   //
   rndm::NuRandomService& Seeds = *(art::ServiceHandle<rndm::NuRandomService>());
   // NuRandomService::createEngine() can't be called here
   //   because it needs a EngineCreator: good
   
   for (auto& engine: engines) {
     
     // NuRandomService::registerEngine() should instead succeed;
     // rndm::NuRandomService::TRandomSeeder is optionally declared (inline)
     // in NuRandomService.h
     auto seed = Seeds.registerEngine
       (rndm::NuRandomService::TRandomSeeder(engine.get()), engine->GetTitle());
     
     mf::LogInfo("GlobalEngineUserTestService")
       << "Registered my random engine "
       << engine->IsA()->GetName() << "[" << ((void*) engine.get()) << "]"
       << " with seed " << seed;
     
   } // for
 
   //
   // let's check that the seeds were actually set
   //
   if (perEventSeeds) {
     mf::LogWarning("GlobalEngineUserTestService")
       << "Check of seeds on construction skipped because policy is per event.";
   }
   else CheckAllSeeds();
   
   //
   // register callbacks
   //
   reg.sPreModuleConstruction.watch (this, &GlobalEngineUserTestService::preModuleConstruction  );
   reg.sPostModuleConstruction.watch(this, &GlobalEngineUserTestService::postModuleConstruction );
   reg.sPreModuleBeginRun.watch     (this, &GlobalEngineUserTestService::preModuleBeginRun      );
   reg.sPostModuleBeginRun.watch    (this, &GlobalEngineUserTestService::postModuleBeginRun     );
   reg.sPreProcessEvent.watch       (this, &GlobalEngineUserTestService::preProcessEvent        );
   reg.sPreModule.watch             (this, &GlobalEngineUserTestService::preModule              );
   reg.sPostModule.watch            (this, &GlobalEngineUserTestService::postModule             );
   reg.sPostProcessEvent.watch      (this, &GlobalEngineUserTestService::postProcessEvent       );
   reg.sPreModuleEndJob.watch       (this, &GlobalEngineUserTestService::preModuleEndJob        );
   reg.sPostModuleEndJob.watch      (this, &GlobalEngineUserTestService::postModuleEndJob       );
   
 } // testing::GlobalEngineUserTestService::GlobalEngineUserTestService

Member Function Documentation

void testing::GlobalEngineUserTestService::CheckAllSeeds ( ) const

private

Checks all engines by CheckSeed() calls.

Definition at line 135 of file GlobalEngineUserTestService_service.cc.

                                                              {
   mf::LogVerbatim("GlobalEngineUserTestService")
     << "Checking all " << engines.size() << " seeds";
   for (auto& engine: engines) CheckSeed(*engine);
 } // testing::GlobalEngineUserTestService::CheckAllSeeds()

void testing::GlobalEngineUserTestService::CheckSeed ( TRandom const & engine )

staticprivate

Throws an exception if the seed is not expected.

Definition at line 109 of file GlobalEngineUserTestService_service.cc.

                                                                         {
   
   auto& Seeds = *(art::ServiceHandle<rndm::NuRandomService>());
   
   auto expectedSeed = Seeds.getGlobalCurrentSeed(engine.GetTitle());
   auto actualSeed = engine.GetSeed();
   
   if (actualSeed != expectedSeed) {
     mf::LogError("GlobalEngineUserTestService")
       << "Engine " << engine.IsA()->GetName() << "[" << ((void*) &engine)
       << "](\"" << engine.GetTitle() << "\") has seed " << actualSeed
       << " (expected: " << expectedSeed << ")";
   }
   else {
     mf::LogVerbatim("GlobalEngineUserTestService")
       << "Engine " << engine.IsA()->GetName() << "[" << ((void*) &engine)
       << "](\"" << engine.GetTitle() << "\") has seed " << actualSeed
       << " (as expected)";
   }
   if (actualSeed != expectedSeed) {
     throw art::Exception(art::errors::LogicError)
       << "Unexpected seed " << actualSeed << "!\n";
   }
 } // testing::GlobalEngineUserTestService::CheckSeed()

void testing::GlobalEngineUserTestService::postModule ( art::ModuleContext const & )

private

Definition at line 205 of file GlobalEngineUserTestService_service.cc.

 {
    if (!perEventSeeds) {
      MF_LOG_DEBUG("GlobalEngineUserTestService")
        << "GlobalEngineUserTestService::postModule()";
      CheckAllSeeds();
    }
 } // testing::GlobalEngineUserTestService::postModule()

void testing::GlobalEngineUserTestService::postModuleBeginRun ( art::ModuleContext const & )

private

Definition at line 178 of file GlobalEngineUserTestService_service.cc.

 {
    if (!perEventSeeds) {
      MF_LOG_DEBUG("GlobalEngineUserTestService")
        << "GlobalEngineUserTestService::postModuleBeginRun()";
      CheckAllSeeds();
    }
 } // testing::GlobalEngineUserTestService::postModuleBeginRun()

void testing::GlobalEngineUserTestService::postModuleConstruction ( art::ModuleDescription const & )

private

Definition at line 156 of file GlobalEngineUserTestService_service.cc.

 {
    if (!perEventSeeds) {
      MF_LOG_DEBUG("GlobalEngineUserTestService")
        << "GlobalEngineUserTestService::postModuleConstruction()";
      CheckAllSeeds();
    }
 } // testing::GlobalEngineUserTestService::postModuleConstruction()

void testing::GlobalEngineUserTestService::postModuleEndJob ( art::ModuleDescription const & )

private

Definition at line 234 of file GlobalEngineUserTestService_service.cc.

 {
    if (!perEventSeeds) {
      MF_LOG_DEBUG("GlobalEngineUserTestService")
        << "GlobalEngineUserTestService::postModuleEndJob()";
      CheckAllSeeds();
    }
 } // testing::GlobalEngineUserTestService::preModuleBeginRun()

void testing::GlobalEngineUserTestService::postProcessEvent	(	art::Event const &	,
		art::ScheduleContext
	)

private

Definition at line 215 of file GlobalEngineUserTestService_service.cc.

                                                                                              {
    MF_LOG_DEBUG("GlobalEngineUserTestService")
      << "GlobalEngineUserTestService::postProcessEvent()";
    CheckAllSeeds();
 } // testing::GlobalEngineUserTestService::postProcessEvent()

void testing::GlobalEngineUserTestService::preModule ( art::ModuleContext const & )

private

Definition at line 196 of file GlobalEngineUserTestService_service.cc.

 {
    MF_LOG_DEBUG("GlobalEngineUserTestService")
      << "GlobalEngineUserTestService::preModule()";
    CheckAllSeeds();
 } // testing::GlobalEngineUserTestService::preModule()

void testing::GlobalEngineUserTestService::preModuleBeginRun ( art::ModuleContext const & )

private

Definition at line 167 of file GlobalEngineUserTestService_service.cc.

 {
    if (!perEventSeeds) {
      MF_LOG_DEBUG("GlobalEngineUserTestService")
        << "GlobalEngineUserTestService::preModuleBeginRun()";
      CheckAllSeeds();
    }
 } // testing::GlobalEngineUserTestService::preModuleBeginRun()

void testing::GlobalEngineUserTestService::preModuleConstruction ( art::ModuleDescription const & )

private

Definition at line 145 of file GlobalEngineUserTestService_service.cc.

 {
    if (!perEventSeeds) {
      MF_LOG_DEBUG("GlobalEngineUserTestService")
        << "GlobalEngineUserTestService::preModuleConstruction()";
      CheckAllSeeds();
    }
 } // testing::GlobalEngineUserTestService::preModuleConstruction()

void testing::GlobalEngineUserTestService::preModuleEndJob ( art::ModuleDescription const & )

private

Definition at line 223 of file GlobalEngineUserTestService_service.cc.

 {
    if (!perEventSeeds) {
      MF_LOG_DEBUG("GlobalEngineUserTestService")
        << "GlobalEngineUserTestService::preModuleEndJob()";
      CheckAllSeeds();
    }
 } // testing::GlobalEngineUserTestService::preModuleBeginRun()

void testing::GlobalEngineUserTestService::preProcessEvent	(	art::Event const &	evt,
		art::ScheduleContext
	)

private

Definition at line 188 of file GlobalEngineUserTestService_service.cc.

                                                                                             {
    MF_LOG_DEBUG("GlobalEngineUserTestService")
      << "GlobalEngineUserTestService::preProcessEvent()";
    CheckAllSeeds();
 } // testing::GlobalEngineUserTestService::preProcessEvent()