#include "PathManager.h"

Public Types
using	Workers = std::vector< Worker * >

using	vstring = std::vector< std::string >

Public Member Functions
	PathManager (PathManager const &)=delete

PathManager &	operator= (PathManager const &)=delete

	PathManager (fhicl::ParameterSet const &procPS, MasterProductRegistry &preg, ProductDescriptions &productsToProduce, ActionTable &exceptActions, ActivityRegistry &areg)

vstring const &	triggerPathNames () const

PathsInfo &	endPathInfo ()

PathsInfo &	triggerPathsInfo (ScheduleID sID)

void	resetAll ()

Private Types
using	ModInfos = PathsInfo::ModInfos

Private Member Functions
detail::ModuleConfigInfoMap	fillAllModules_ ()

vstring	processPathConfigs_ ()

bool	processOnePathConfig_ (std::string const &path_name, vstring const &path_seq, vstring &trigger_path_names, std::ostream &error_stream)

Private Attributes
fhicl::ParameterSet	procPS_

MasterProductRegistry &	preg_

ProductDescriptions &	productsToProduce_

ActionTable &	exceptActions_

ActivityRegistry &	areg_

std::unique_ptr< std::set< std::string > >	trigger_paths_config_

std::unique_ptr< std::set< std::string > >	end_paths_config_

detail::ModuleFactory	fact_ {}

detail::ModuleConfigInfoMap	allModules_

std::map< std::string, ModInfos >	protoTrigPathMap_ {}

ModInfos	protoEndPathInfo_ {}

vstring	triggerPathNames_

PathsInfo	endPathInfo_

std::map< ScheduleID, PathsInfo >	triggerPathsInfo_ {}

Detailed Description

Definition at line 36 of file PathManager.h.

Member Typedef Documentation

using art::PathManager::ModInfos = PathsInfo::ModInfos

private

Definition at line 59 of file PathManager.h.

using art::PathManager::vstring = std::vector<std::string>

Definition at line 42 of file PathManager.h.

using art::PathManager::Workers = std::vector<Worker*>

Definition at line 41 of file PathManager.h.

Constructor & Destructor Documentation

art::PathManager::PathManager ( PathManager const & )

delete

art::PathManager::PathManager	(	fhicl::ParameterSet const &	procPS,
		MasterProductRegistry &	preg,
		ProductDescriptions &	productsToProduce,
		ActionTable &	exceptActions,
		ActivityRegistry &	areg
	)

Definition at line 108 of file PathManager.cc.

References allModules_, areg_, end_paths_config_, endPathInfo_, exceptActions_, fact_, fillAllModules_(), preg_, processPathConfigs_(), procPS_, productsToProduce_, trigger_paths_config_, and triggerPathNames_.

   : procPS_{procPS}
   , preg_{preg}
   , productsToProduce_{productsToProduce}
   , exceptActions_{exceptActions}
   , areg_{areg}
   , trigger_paths_config_{findLegacyConfig(procPS_, "physics.trigger_paths")}
   , end_paths_config_{findLegacyConfig(procPS_, "physics.end_paths")}
   , allModules_{fillAllModules_()}
   , triggerPathNames_{processPathConfigs_()}
   , endPathInfo_{0,
                  fact_,
                  procPS_,
                  preg_,
                  productsToProduce_,
                  exceptActions_,
                  areg_}
 {}

Member Function Documentation

art::PathsInfo & art::PathManager::endPathInfo ( )

Definition at line 132 of file PathManager.cc.

References endPathInfo_, art::PathsInfo::makeAndAppendPath(), art::PathsInfo::pathPtrs(), and protoEndPathInfo_.

Referenced by art::EndPathExecutor::EndPathExecutor(), art::EventProcessor::invokePostBeginJobWorkers_(), and art::detail::writeSummary().

 {
   if (!protoEndPathInfo_.empty() && endPathInfo_.pathPtrs().empty()) {
     // Need to create path from proto information.  No trigger results
     // needed for end path.
     endPathInfo_.makeAndAppendPath("end_path", protoEndPathInfo_, false);
   }
   return endPathInfo_;
 }

art::detail::ModuleConfigInfoMap art::PathManager::fillAllModules_ ( )

private

Definition at line 169 of file PathManager.cc.

References art::detail::ModuleConfigInfo::allModulePathRoots(), art::errors::Configuration, e, fact_, fhicl::ParameterSet::get(), art::detail::ModuleFactory::moduleType(), procPS_, and art::to_string().

Referenced by PathManager().

 {
   detail::ModuleConfigInfoMap all_modules;
   std::ostringstream error_stream;
   for (auto const& pathRootName :
        detail::ModuleConfigInfo::allModulePathRoots()) {
     auto const pathRoot = procPS_.get<ParameterSet>(pathRootName, {});
     for (auto const& name : pathRoot.get_names()) {
       try {
         detail::ModuleConfigInfo const mci{procPS_, name, pathRootName};
         auto actualModType = fact_.moduleType(mci.libSpec());
         if (actualModType != mci.moduleType()) {
           error_stream << "  ERROR: Module with label " << mci.label()
                        << " of type " << mci.libSpec() << " is configured as a "
                        << to_string(mci.moduleType())
                        << " but defined in code as a "
                        << to_string(actualModType) << ".\n";
         }
         auto result = all_modules.emplace(mci.label(), mci);
         if (!result.second) {
           error_stream << "  ERROR: Module label " << mci.label()
                        << " has been used in "
                        << result.first->second.configPath() << " and "
                        << pathRootName << ".\n";
         }
       }
       catch (std::exception const& e) {
         error_stream << "  ERROR: Configuration of module with label " << name
                      << " encountered the following error:\n"
                      << e.what() << "\n";
       }
     }
   }
   auto error_messages = error_stream.str();
   if (!error_messages.empty()) {
     throw Exception(errors::Configuration)
       << "The following were encountered while processing the module "
          "configurations:\n"
       << error_messages;
   }
   return all_modules;
 }

PathManager& art::PathManager::operator= ( PathManager const & )

delete

bool art::PathManager::processOnePathConfig_	(	std::string const &	path_name,
		vstring const &	path_seq,
		vstring &	trigger_path_names,
		std::ostream &	error_stream
	)

private

Definition at line 302 of file PathManager.cc.

References allModules_, end_paths_config_, art::FILTER, art::is_observer(), art::WorkerInPath::Normal, protoEndPathInfo_, protoTrigPathMap_, art::to_string(), and trigger_paths_config_.

Referenced by processPathConfigs_().

 {
   enum class mod_cat_t { UNSET, OBSERVER, MODIFIER };
   mod_cat_t cat{mod_cat_t::UNSET};
   for (auto const& modname : path_seq) {
     auto const label = stripLabel(modname);
     auto const it = allModules_.find(label);
     if (it == cend(allModules_)) {
       error_stream << "  ERROR: Entry " << modname << " in path " << path_name
                    << " refers to a module label " << label
                    << " which is not configured.\n";
       continue;
     }
     auto const& mci = it->second;
     auto mtype =
       is_observer(mci.moduleType()) ? mod_cat_t::OBSERVER : mod_cat_t::MODIFIER;
     if (cat == mod_cat_t::UNSET) {
       cat = mtype;
       // Efficiency.
       if (cat == mod_cat_t::MODIFIER) {
         if (trigger_paths_config_ && (trigger_paths_config_->find(path_name) ==
                                       trigger_paths_config_->cend())) {
           mf::LogInfo("DeactivatedPath")
             << "Detected trigger path \"" << path_name
             << "\" which was not found in\n"
             << "parameter \"physics.trigger_paths\". "
             << "Path will be ignored.";
           return false;
         }
         // Handle case where user accidentally specified a trigger
         // path as an end path.
         if (end_paths_config_ &&
             (end_paths_config_->find(path_name) != end_paths_config_->cend())) {
           error_stream
             << "  ERROR: Path "
             << "'" << path_name << "'"
             << " is configured as an end path but is actually a trigger path.";
         }
         trigger_path_names.push_back(path_name);
         protoTrigPathMap_[path_name].reserve(path_seq.size());
       } else {
         if (end_paths_config_ &&
             (end_paths_config_->find(path_name) == end_paths_config_->cend())) {
           mf::LogInfo("DeactivatedPath") << "Detected end path \"" << path_name
                                          << "\" which was not found in\n"
                                          << "parameter \"physics.end_paths\". "
                                          << "Path will be ignored.";
           return false;
         }
         // Handle case where user accidentally specified an end path
         // as a trigger path.
         if (trigger_paths_config_ && (trigger_paths_config_->find(path_name) !=
                                       trigger_paths_config_->cend())) {
           error_stream
             << "  ERROR: Path "
             << "'" << path_name << "'"
             << " is configured as a trigger path but is actually an end path.";
         }
         protoEndPathInfo_.reserve(protoEndPathInfo_.size() + path_seq.size());
       }
     } else if (cat != mtype) {
       error_stream << "  ERROR: Entry " << modname << " in path " << path_name
                    << " is a"
                    << (cat == mod_cat_t::OBSERVER ? " modifier" : "n observer")
                    << " while previous entries in the same path are all "
                    << (cat == mod_cat_t::OBSERVER ? "observers" : "modifiers")
                    << ".\n";
     }
 
     auto const filtAction = filterAction(modname);
     if (mci.moduleType() != ModuleType::FILTER &&
         filtAction != WorkerInPath::Normal) {
       error_stream << "  ERROR: Module " << stripLabel(modname) << " in path "
                    << path_name << " is"
                    << (cat == mod_cat_t::OBSERVER ? " an " : " a ")
                    << to_string(mci.moduleType())
                    << " and cannot have a '!' or '-' prefix.\n";
     }
 
     if (cat == mod_cat_t::MODIFIER) {
       protoTrigPathMap_[path_name].emplace_back(mci, filtAction);
     } else { // Only one end path.
       protoEndPathInfo_.emplace_back(mci, filtAction);
     }
   }
   return (cat == mod_cat_t::OBSERVER);
 }

art::PathManager::vstring art::PathManager::processPathConfigs_ ( )

private

Definition at line 213 of file PathManager.cc.

References allModules_, art::errors::Configuration, e, end_paths_config_, fhicl::ParameterSet::get(), fhicl::ParameterSet::get_names(), processOnePathConfig_(), procPS_, and trigger_paths_config_.

Referenced by PathManager().

 {
   vstring trigger_path_names;
   auto nSchedules[[gnu::unused]] =
     procPS_.get<size_t>("services.scheduler.num_schedules", 1);
   // Identify and process paths.
   std::set<std::string> known_pars{
     "analyzers", "filters", "producers", "trigger_paths", "end_paths"};
   ParameterSet empty;
   auto const physics = procPS_.get<ParameterSet>("physics", empty);
   auto const keys = physics.get_names();
   vstring path_names;
   std::set_difference(keys.cbegin(),
                       keys.cend(),
                       known_pars.cbegin(),
                       known_pars.cend(),
                       std::back_inserter(path_names));
   std::set<std::string> specified_modules;
   std::ostringstream error_stream;
 
   // Check for missing specified paths.
   if (trigger_paths_config_) {
     check_missing_paths(
       *trigger_paths_config_, path_names, "trigger_paths", error_stream);
   }
   if (end_paths_config_) {
     check_missing_paths(
       *end_paths_config_, path_names, "end_paths", error_stream);
   }
 
   check_misspecified_paths(physics, path_names);
 
   // Process each path.
   size_t num_end_paths{0};
   for (auto const& path_name : path_names) {
     auto const path_seq = physics.get<vstring>(path_name);
     if (processOnePathConfig_(
           path_name, path_seq, trigger_path_names, error_stream)) {
       ++num_end_paths;
     }
     for (auto const& mod : path_seq) {
       specified_modules.insert(stripLabel(mod));
     }
   }
   if (num_end_paths > 1) {
     mf::LogInfo("PathConfiguration")
       << "Multiple end paths have been combined into one end path,\n"
       << "\"end_path\" since order is irrelevant.\n";
   }
 
   vstring unused_modules;
   std::set<std::string> all_module_labels;
   for (auto const& val : allModules_) {
     all_module_labels.insert(val.first);
   }
 
   std::set_difference(all_module_labels.cbegin(),
                       all_module_labels.cend(),
                       specified_modules.cbegin(),
                       specified_modules.cend(),
                       std::back_inserter(unused_modules));
 
   // Complain about unused modules.
   if (!unused_modules.empty()) {
     std::ostringstream unusedStream;
     unusedStream << "The following module label"
                  << ((unused_modules.size() == 1) ? " is" : "s are")
                  << " not assigned to any path:\n"
                  << "'" << unused_modules.front() << "'";
     for (auto i = unused_modules.cbegin() + 1, e = unused_modules.cend();
          i != e;
          ++i) {
       unusedStream << ", '" << *i << "'";
     }
     mf::LogInfo("path") << unusedStream.str() << "\n";
   }
 
   // Check for fatal errors.
   auto error_messages = error_stream.str();
   if (!error_messages.empty()) {
     throw Exception(errors::Configuration, "Path configuration: ")
       << "The following were encountered while processing path "
          "configurations:\n"
       << error_messages;
   }
   return trigger_path_names;
 }

void art::PathManager::resetAll ( )

art::PathManager::vstring const & art::PathManager::triggerPathNames ( ) const

inline

Definition at line 91 of file PathManager.h.

References triggerPathNames_.

Referenced by art::EventProcessor::initServices_().

 {
   return triggerPathNames_;
 }

art::PathsInfo & art::PathManager::triggerPathsInfo ( ScheduleID sID )

Definition at line 143 of file PathManager.cc.

References protoTrigPathMap_, and triggerPathsInfo_.

Referenced by art::EventProcessor::invokePostBeginJobWorkers_(), and art::detail::writeSummary().

 {
   auto it = triggerPathsInfo_.find(sID);
   if (it != triggerPathsInfo_.end())
     return it->second;
 
   it = triggerPathsInfo_
          .emplace(sID,
                   PathsInfo{triggerPathNames_.size(),
                             fact_,
                             procPS_,
                             preg_,
                             productsToProduce_,
                             exceptActions_,
                             areg_})
          .first;
   auto& pathsInfo = it->second;
 
   for (auto const& val : protoTrigPathMap_) {
     pathsInfo.makeAndAppendPath(val.first, val.second);
   };
 
   return pathsInfo;
 }

Member Data Documentation

detail::ModuleConfigInfoMap art::PathManager::allModules_

private

Definition at line 82 of file PathManager.h.

Referenced by PathManager(), processOnePathConfig_(), and processPathConfigs_().

ActivityRegistry& art::PathManager::areg_

private

Definition at line 73 of file PathManager.h.

Referenced by PathManager().

std::unique_ptr<std::set<std::string> > art::PathManager::end_paths_config_

private

Definition at line 79 of file PathManager.h.

Referenced by PathManager(), processOnePathConfig_(), and processPathConfigs_().

PathsInfo art::PathManager::endPathInfo_

private

Definition at line 86 of file PathManager.h.

Referenced by endPathInfo(), and PathManager().

ActionTable& art::PathManager::exceptActions_

private

Definition at line 72 of file PathManager.h.

Referenced by PathManager().

detail::ModuleFactory art::PathManager::fact_ {}

private

Definition at line 81 of file PathManager.h.

Referenced by fillAllModules_(), and PathManager().

MasterProductRegistry& art::PathManager::preg_

private

Definition at line 70 of file PathManager.h.

Referenced by PathManager().

fhicl::ParameterSet art::PathManager::procPS_

private

Definition at line 69 of file PathManager.h.

Referenced by fillAllModules_(), PathManager(), and processPathConfigs_().

ProductDescriptions& art::PathManager::productsToProduce_

private

Definition at line 71 of file PathManager.h.

Referenced by PathManager().

ModInfos art::PathManager::protoEndPathInfo_ {}

private

Definition at line 84 of file PathManager.h.

Referenced by endPathInfo(), and processOnePathConfig_().

std::map<std::string, ModInfos> art::PathManager::protoTrigPathMap_ {}

private

Definition at line 83 of file PathManager.h.

Referenced by processOnePathConfig_(), and triggerPathsInfo().

std::unique_ptr<std::set<std::string> > art::PathManager::trigger_paths_config_

private

Definition at line 78 of file PathManager.h.

Referenced by PathManager(), processOnePathConfig_(), and processPathConfigs_().

vstring art::PathManager::triggerPathNames_

private

Definition at line 85 of file PathManager.h.

Referenced by PathManager(), and triggerPathNames().

std::map<ScheduleID, PathsInfo> art::PathManager::triggerPathsInfo_ {}

private

Definition at line 87 of file PathManager.h.

Referenced by triggerPathsInfo().

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

art/Framework/Core/PathManager.h
art/Framework/Core/PathManager.cc

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation