art::Schedule Class Reference

#include "Schedule.h"

Public Member Functions
	Schedule (ScheduleID, PathManager &, fhicl::ParameterSet const &, TriggerNamesService const &, MasterProductRegistry &, ProductDescriptions &, ActionTable &, ActivityRegistry &)
template<typename T >
void	process (typename T::MyPrincipal &)
void	beginJob ()
void	endJob ()
void	respondToOpenInputFile (FileBlock const &)
void	respondToCloseInputFile (FileBlock const &)
void	respondToOpenOutputFiles (FileBlock const &)
void	respondToCloseOutputFiles (FileBlock const &)

Private Member Functions
void	makeTriggerResultsInserter_ (fhicl::ParameterSet const &trig_pset, MasterProductRegistry &mpr, ProductDescriptions &productsToProduce, ActivityRegistry &areg)
template<typename T >
bool	runTriggerPaths_ (typename T::MyPrincipal &)
template<class F >
void	doForAllWorkers_ (F functor)
template<class F >
void	doForAllEnabledPaths_ (F functor)

Private Attributes
ScheduleID const	sID_
fhicl::ParameterSet	process_pset_
ActionTable *	act_table_
std::string	processName_
PathsInfo &	triggerPathsInfo_
std::vector< unsigned char >	pathsEnabled_
std::unique_ptr< Worker >	results_inserter_ {nullptr}

Detailed Description

Definition at line 62 of file Schedule.h.

Constructor & Destructor Documentation

art::Schedule::Schedule	(	ScheduleID	sID,
		PathManager &	pm,
		fhicl::ParameterSet const &	proc_pset,
		TriggerNamesService const &	tns,
		MasterProductRegistry &	mpr,
		ProductDescriptions &	productsToProduce,
		ActionTable &	actions,
		ActivityRegistry &	areg
	)

Definition at line 29 of file Schedule.cc.

References act_table_, makeTriggerResultsInserter_(), art::PathsInfo::pathPtrs(), pathsEnabled_, process_pset_, processName_, sID_, and triggerPathsInfo_.

  : sID_{sID}
  , process_pset_{proc_pset}
  , act_table_{&actions}
  , processName_{tns.getProcessName()}
  , triggerPathsInfo_{pm.triggerPathsInfo(sID_)}
  , pathsEnabled_(triggerPathsInfo_.pathPtrs().size(), true)
{
  if (!triggerPathsInfo_.pathPtrs().empty()) {
    makeTriggerResultsInserter_(
      tns.getTriggerPSet(), mpr, productsToProduce, areg);
  }
}

Member Function Documentation

void art::Schedule::beginJob

(

)

Definition at line 104 of file Schedule.cc.

References doForAllWorkers_(), and w.

{
  doForAllWorkers_([](auto w) { w->beginJob(); });
}

template<class F >

void art::Schedule::doForAllEnabledPaths_ ( F  functor )

private

Definition at line 175 of file Schedule.h.

References art::PathsInfo::pathPtrs(), pathsEnabled_, and triggerPathsInfo_.

Referenced by runTriggerPaths_().

  {
    size_t path_index = 0;
    for (auto const& path : triggerPathsInfo_.pathPtrs()) {
      if (pathsEnabled_[path_index++]) {
        functor(path.get());
      }
    }
  }

template<class F >

void art::Schedule::doForAllWorkers_ ( F  functor )

private

Definition at line 162 of file Schedule.h.

References results_inserter_, triggerPathsInfo_, and art::PathsInfo::workers().

Referenced by beginJob(), endJob(), process(), respondToCloseInputFile(), respondToCloseOutputFiles(), respondToOpenInputFile(), and respondToOpenOutputFiles().

  {
    for (auto const& val : triggerPathsInfo_.workers()) {
      functor(val.second.get());
    }
    if (results_inserter_) {
      // Do this last -- not part of main list.
      functor(results_inserter_.get());
    }
  }

void art::Schedule::endJob

(

)

Definition at line 51 of file Schedule.cc.

References doForAllWorkers_(), e, art::Worker::endJob(), art::errors::EndJobFailure, and w.

{
  bool failure = false;
  Exception error(errors::EndJobFailure);
  doForAllWorkers_([&failure, &error](Worker* w) {
    try {
      w->endJob();
    }
    catch (cet::exception& e) {
      error << "cet::exception caught in Schedule::endJob\n"
            << e.explain_self();
      failure = true;
    }
    catch (std::exception& e) {
      error << "Standard library exception caught in Schedule::endJob\n"
            << e.what();
      failure = true;
    }
    catch (...) {
      error << "Unknown exception caught in Schedule::endJob\n";
      failure = true;
    }
  });
  if (failure) {
    throw error;
  }
}

void art::Schedule::makeTriggerResultsInserter_ ( fhicl::ParameterSet const &  trig_pset, MasterProductRegistry &  mpr, ProductDescriptions &  productsToProduce, ActivityRegistry &  areg  )

private

Definition at line 110 of file Schedule.cc.

References act_table_, art::getReleaseVersion(), fhicl::ParameterSet::id(), art::PathsInfo::pathResults(), process_pset_, processName_, results_inserter_, art::ActivityRegistry::sPostModuleConstruction, art::ActivityRegistry::sPreModuleConstruction, and triggerPathsInfo_.

Referenced by Schedule().

{
  WorkerParams const work_args{process_pset_,
                               trig_pset,
                               mpr,
                               productsToProduce,
                               *act_table_,
                               processName_};
  ModuleDescription md(trig_pset.id(),
                       "TriggerResultInserter",
                       "TriggerResults",
                       ProcessConfiguration(processName_,
                                            process_pset_.id(),
                                            getReleaseVersion()));
  areg.sPreModuleConstruction.invoke(md);
  auto producer = std::make_unique<TriggerResultInserter>(
    trig_pset, triggerPathsInfo_.pathResults());
  results_inserter_ =
    std::make_unique<WorkerT<EDProducer>>(std::move(producer), md, work_args);
  areg.sPostModuleConstruction.invoke(md);
  results_inserter_->setActivityRegistry(cet::make_exempt_ptr(&areg));
}

template<typename T >

void art::Schedule::process

(

typename T::MyPrincipal &

principal

)

Definition at line 119 of file Schedule.h.

References act_table_, art::PathsInfo::addEvent(), art::PathsInfo::addPass(), doForAllWorkers_(), e, art::Event, art::actions::FailModule, art::actions::FailPath, art::ActionTable::find(), art::actions::IgnoreCompletely, art::PathsInfo::pathResults(), art::HLTGlobalStatus::reset(), results_inserter_, art::actions::Rethrow, art::actions::SkipEvent, triggerPathsInfo_, and w.

  {
    doForAllWorkers_([](auto w) { w->reset(); });
    triggerPathsInfo_.pathResults().reset();
    if (T::level == Level::Event) {
      triggerPathsInfo_.addEvent();
    }
    try {
      if (runTriggerPaths_<T>(principal) && T::level == Level::Event) {
        triggerPathsInfo_.addPass();
      }
      if (results_inserter_.get()) {
        results_inserter_->doWork<T>(principal, 0);
      }
    }
    catch (cet::exception& e) {
      actions::ActionCodes const action = {T::level == Level::Event ?
                                             act_table_->find(e.root_cause()) :
                                             actions::Rethrow};
      assert(action != actions::IgnoreCompletely);
      assert(action != actions::FailPath);
      assert(action != actions::FailModule);
      if (action == actions::SkipEvent) {
        mf::LogWarning(e.category())
          << "an exception occurred and all paths for "
             "the event are being skipped: \n"
          << cet::trim_right_copy(e.what(), " \n");
      } else {
        throw;
      }
    }
  }

void art::Schedule::respondToCloseInputFile

(

FileBlock const &

fb

)

Definition at line 86 of file Schedule.cc.

References doForAllWorkers_(), and w.

{
  doForAllWorkers_([&fb](auto w) { w->respondToCloseInputFile(fb); });
}

void art::Schedule::respondToCloseOutputFiles

(

FileBlock const &

fb

)

Definition at line 98 of file Schedule.cc.

References doForAllWorkers_(), and w.

{
  doForAllWorkers_([&fb](auto w) { w->respondToCloseOutputFiles(fb); });
}

void art::Schedule::respondToOpenInputFile

(

FileBlock const &

fb

)

Definition at line 80 of file Schedule.cc.

References doForAllWorkers_(), and w.

{
  doForAllWorkers_([&fb](auto w) { w->respondToOpenInputFile(fb); });
}

void art::Schedule::respondToOpenOutputFiles

(

FileBlock const &

fb

)

Definition at line 92 of file Schedule.cc.

References doForAllWorkers_(), and w.

{
  doForAllWorkers_([&fb](auto w) { w->respondToOpenOutputFiles(fb); });
}

template<typename T >

bool art::Schedule::runTriggerPaths_ ( typename T::MyPrincipal &  ep )

inlineprivate

Definition at line 154 of file Schedule.h.

References art::HLTGlobalStatus::accept(), doForAllEnabledPaths_(), art::PathsInfo::pathResults(), and triggerPathsInfo_.

  {
    doForAllEnabledPaths_([&ep](auto p) { p->template process<T>(ep); });
    return triggerPathsInfo_.pathResults().accept();
  }

Member Data Documentation

ActionTable* art::Schedule::act_table_

private

Definition at line 110 of file Schedule.h.

Referenced by makeTriggerResultsInserter_(), process(), and Schedule().

std::vector<unsigned char> art::Schedule::pathsEnabled_

private

Definition at line 113 of file Schedule.h.

Referenced by doForAllEnabledPaths_(), and Schedule().

fhicl::ParameterSet art::Schedule::process_pset_

private

Definition at line 109 of file Schedule.h.

Referenced by makeTriggerResultsInserter_(), and Schedule().

std::string art::Schedule::processName_

private

Definition at line 111 of file Schedule.h.

Referenced by makeTriggerResultsInserter_(), and Schedule().

std::unique_ptr<Worker> art::Schedule::results_inserter_ {nullptr}

private

Definition at line 114 of file Schedule.h.

Referenced by doForAllWorkers_(), makeTriggerResultsInserter_(), and process().

ScheduleID const art::Schedule::sID_

private

Definition at line 108 of file Schedule.h.

Referenced by Schedule().

PathsInfo& art::Schedule::triggerPathsInfo_

private

Definition at line 112 of file Schedule.h.

Referenced by doForAllEnabledPaths_(), doForAllWorkers_(), makeTriggerResultsInserter_(), process(), runTriggerPaths_(), and Schedule().

---

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

• art/Framework/Core/Schedule.h
• art/Framework/Core/Schedule.cc