art::OutputWorker Class Reference

#include "OutputWorker.h"

Inheritance diagram for art::OutputWorker:

Public Types
using	ModuleType = OutputModule
using	WorkerType = WorkerT< OutputModule >
enum	State {   Ready, Pass, Fail, Working,   Exception }

Public Member Functions
	OutputWorker (std::unique_ptr< OutputModule > &&mod, ModuleDescription const &, WorkerParams const &)
virtual	~OutputWorker ()
std::string const &	lastClosedFileName () const
void	closeFile ()
bool	fileIsOpen () const
void	incrementInputFileNumber ()
bool	requestsToCloseFile () const
bool	wantAllEvents () const
void	openFile (FileBlock const &fb)
void	writeRun (RunPrincipal &rp)
void	writeSubRun (SubRunPrincipal &srp)
void	writeEvent (EventPrincipal &ep)
void	setRunAuxiliaryRangeSetID (RangeSet const &)
void	setSubRunAuxiliaryRangeSetID (RangeSet const &)
bool	limitReached () const
void	setFileStatus (OutputFileStatus)
void	configure (OutputModuleDescription const &desc)
Granularity	fileGranularity () const
virtual void	selectProducts (ProductList const &)
bool	modifiesEvent () const override
template<typename T >
bool	doWork (typename T::MyPrincipal &, CurrentProcessingContext const *cpc)
void	beginJob ()
void	endJob ()
void	respondToOpenInputFile (FileBlock const &fb)
void	respondToCloseInputFile (FileBlock const &fb)
void	respondToOpenOutputFiles (FileBlock const &fb)
void	respondToCloseOutputFiles (FileBlock const &fb)
void	reset ()
ModuleDescription const &	description () const
ModuleDescription const *	descPtr () const
void	setActivityRegistry (cet::exempt_ptr< ActivityRegistry > areg)
void	clearCounters ()
std::size_t	timesRun () const
std::size_t	timesVisited () const
std::size_t	timesPassed () const
std::size_t	timesFailed () const
std::size_t	timesExcept () const
State	state () const
std::string const &	label () const

Protected Member Functions
OutputModule &	module ()
OutputModule const &	module () const

Private Attributes
ServiceHandle< CatalogInterface >	ci_
Granularity	fileGranularity_ {Granularity::Unset}

Detailed Description

Definition at line 29 of file OutputWorker.h.

Member Typedef Documentation

using art::WorkerT< OutputModule >::ModuleType = OutputModule

inherited

Definition at line 24 of file WorkerT.h.

using art::WorkerT< OutputModule >::WorkerType = WorkerT<OutputModule >

inherited

Definition at line 25 of file WorkerT.h.

Member Enumeration Documentation

enum art::Worker::State

inherited

Enumerator
Ready
Pass
Fail
Working
Exception

Definition at line 53 of file Worker.h.

{ Ready, Pass, Fail, Working, Exception };

Constructor & Destructor Documentation

art::OutputWorker::OutputWorker	(	std::unique_ptr< OutputModule > &&	mod,
		ModuleDescription const &	md,
		WorkerParams const &	wp
	)

Definition at line 9 of file OutputWorker.cc.

References ci_, art::Worker::description(), fhicl::ParameterSetRegistry::get(), and art::Worker::label().

    : WorkerT<OutputModule>(std::move(mod), md, wp), ci_()
  {
    ci_->outputModuleInitiated(
      label(),
      fhicl::ParameterSetRegistry::get(description().parameterSetID()));
  }

art::OutputWorker::~OutputWorker ( )

virtual

Definition at line 19 of file OutputWorker.cc.

{}

Member Function Documentation

void art::Worker::beginJob ( )

inherited

Definition at line 18 of file Worker.cc.

References art::Worker::actReg_, art::errors::BadExceptionType, art::Worker::description(), e, art::Worker::implBeginJob(), art::Worker::md_, art::errors::OtherArt, s, art::errors::StdException, art::errors::Unknown, and art::Worker::workerType().

                        {
  assert(actReg_.get() != nullptr);
  actReg_->sPreModuleBeginJob.invoke(md_);
  implBeginJob();
  actReg_->sPostModuleBeginJob.invoke(md_);
}
catch (cet::exception& e) {
  // should event id be included?
  LogError("BeginJob") << "A cet::exception is going through " << workerType()
                       << ":\n";

  e << "A cet::exception is going through " << workerType() << ":\n"
    << description();
  throw art::Exception(errors::OtherArt, std::string(), e);
}
catch (std::bad_alloc& e) {
  LogError("BeginJob") << "A std::bad_alloc is going through " << workerType()
                       << ":\n"
                       << description() << "\n";
  throw;
}
catch (std::exception& e) {
  LogError("BeginJob") << "A std::exception is going through " << workerType()
                       << ":\n"
                       << description() << "\n";
  throw art::Exception(errors::StdException)
    << "A std::exception is going through " << workerType() << ":\n"
    << description() << "\n";
}
catch (std::string& s) {
  LogError("BeginJob") << "module caught an std::string during beginJob\n";

  throw art::Exception(errors::BadExceptionType)
    << "std::string = " << s << "\n"
    << description() << "\n";
}
catch (char const* c) {
  LogError("BeginJob") << "module caught an const char* during beginJob\n";

  throw art::Exception(errors::BadExceptionType) << "cstring = " << c << "\n"
                                                 << description();
}
catch (...) {
  LogError("BeginJob") << "An unknown Exception occurred in\n"
                       << description() << "\n";
  throw art::Exception(errors::Unknown) << "An unknown Exception occurred in\n"
                                        << description() << "\n";
}

void art::Worker::clearCounters ( )

inlineinherited

Definition at line 88 of file Worker.h.

References art::Worker::counts_.

  {
    counts_ = CountingStatistics{};
  }

void art::OutputWorker::closeFile

(

)

Definition at line 28 of file OutputWorker.cc.

References ci_, art::Worker::description(), art::OutputModule::doCloseFile(), lastClosedFileName(), and art::WorkerT< OutputModule >::module().

Referenced by art::EndPathExecutor::closeAllOutputFiles().

  {
    module().doCloseFile();
    ci_->outputFileClosed(description().moduleLabel(),
                          module().lastClosedFileName());
  }

void art::OutputWorker::configure

(

OutputModuleDescription const &

desc

)

Definition at line 109 of file OutputWorker.cc.

References art::OutputModule::configure(), and art::WorkerT< OutputModule >::module().

  {
    module().configure(desc);
  }

ModuleDescription const* art::Worker::descPtr ( ) const

inlineinherited

Definition at line 79 of file Worker.h.

References art::Worker::md_, and art::Worker::setActivityRegistry().

  {
    return &md_;
  }

ModuleDescription const& art::Worker::description ( ) const

inlineinherited

Definition at line 74 of file Worker.h.

References art::Worker::md_.

Referenced by art::Worker::beginJob(), closeFile(), art::Worker::endJob(), openFile(), and OutputWorker().

  {
    return md_;
  }

template<typename T >

bool art::Worker::doWork ( typename T::MyPrincipal &  p, CurrentProcessingContext const *  cpc  )

inherited

Definition at line 218 of file Worker.h.

References art::Worker::actions_, art::Worker::actReg_, art::errors::BadAlloc, art::errors::BadExceptionType, art::Worker::cached_exception_, art::Worker::counts_, e, art::Event, art::Worker::Exception, art::detail::exceptionContext(), art::Worker::Fail, art::actions::FailModule, art::actions::FailPath, art::ActionTable::find(), art::actions::IgnoreCompletely, art::CurrentProcessingContext::isEndPath(), art::Worker::md_, art::errors::OtherArt, art::Worker::Pass, art::Worker::Ready, art::actions::Rethrow, s, art::errors::ScheduleExecutionFailure, art::actions::SkipEvent, art::Worker::state_, art::errors::StdException, art::errors::Unknown, and art::Worker::Working.

{
  MaybeIncrementCounts<T::level, decltype(counts_)> counts{counts_};
  counts.template increment<stats::Visited>();

  switch (state_) {
    case Ready:
      break;
    case Pass:
      return true;
    case Fail:
      return false;
    case Exception: {
      // Rethrow the cached exception again. It seems impossible to
      // get here a second time unless a cet::exception has been
      // thrown previously.
      mf::LogWarning("repeat")
        << "A module has been invoked a second time even though"
           " it caught an exception during the previous invocation."
           "\nThis may be an indication of a configuration problem.\n";
      throw *cached_exception_;
    }
    case Working:
      break; // See below.
  }

  bool rc{false};
  try {
    if (state_ == Working) {
      // Not part of the switch statement above because we want the
      // exception to be caught by our handling mechanism.
      throw art::Exception(errors::ScheduleExecutionFailure)
        << "A Module has been invoked while it is still being executed.\n"
        << "Product dependencies have invoked a module execution cycle.\n";
    }

    assert(actReg_.get() != nullptr);
    state_ = Working;

    T::preModuleSignal(*actReg_, md_);
    rc = ImplDoWork<T::processing_action>::invoke(this, p, cpc);
    T::postModuleSignal(*actReg_, md_);

    state_ = Pass;

    if (T::level == Level::Event && !rc)
      state_ = Fail;
  }
  catch (cet::exception& e) {

    // NOTE: the warning printed as a result of ignoring or failing a
    // module will only be printed during the full true processing
    // pass of this module.

    // Get the action corresponding to this exception.  However, if
    // processing something other than an event (e.g. run, subRun)
    // always rethrow.
    actions::ActionCodes action{T::level == Level::Event ?
                                  actions_.find(e.root_cause()) :
                                  actions::Rethrow};

    // If we are processing an endPath, treat SkipEvent or FailPath as
    // FailModule, so any subsequent OutputModules are still run.
    if (cpc && cpc->isEndPath()) {
      if (action == actions::SkipEvent || action == actions::FailPath)
        action = actions::FailModule;
    }

    switch (action) {
      case actions::IgnoreCompletely: {
        rc = true;
        counts.template increment<stats::Passed>();
        state_ = Pass;
        mf::LogWarning("IgnoreCompletely") << "Module ignored an exception\n"
                                           << e.what();
        break;
      }
      case actions::FailModule: {
        rc = true;
        mf::LogWarning("FailModule") << "Module failed due to an exception\n"
                                     << e.what();
        counts.template increment<stats::Failed>();
        state_ = Fail;
        break;
      }
      default: {
        // We should not need to include the event/run/module names in
        // the exception because the error logger will pick this up
        // automatically.  I'm leaving it in until this is verified.

        // here we simply add a small amount of data to the exception to
        // add some context, we could have rethrown it as something else
        // and embedded with this exception as an argument to the
        // constructor.
        counts.template increment<stats::ExceptionThrown>();
        state_ = Exception;
        e << "cet::exception going through module ";
        detail::exceptionContext(md_, p, e);
        if (auto edmEx = dynamic_cast<art::Exception*>(&e)) {
          cached_exception_ = std::make_shared<art::Exception>(*edmEx);
        } else {
          cached_exception_ = std::make_shared<art::Exception>(
            errors::OtherArt, std::string(), e);
        }
        throw;
      }
    }
  }
  catch (std::bad_alloc const& bda) {
    counts.template increment<stats::ExceptionThrown>();
    state_ = Exception;
    cached_exception_ = std::make_shared<art::Exception>(errors::BadAlloc);
    *cached_exception_
      << "A std::bad_alloc exception occurred during a call to the module ";
    detail::exceptionContext(md_, p, *cached_exception_)
      << "The job has probably exhausted the virtual memory available to the "
         "process.\n";
    throw *cached_exception_;
  }
  catch (std::exception const& e) {
    counts.template increment<stats::ExceptionThrown>();
    state_ = Exception;
    cached_exception_ = std::make_shared<art::Exception>(errors::StdException);
    *cached_exception_
      << "A std::exception occurred during a call to the module ";
    detail::exceptionContext(md_, p, *cached_exception_)
      << "and cannot be repropagated.\n"
      << "Previous information:\n"
      << e.what();
    throw *cached_exception_;
  }
  catch (std::string const& s) {
    counts.template increment<stats::ExceptionThrown>();
    state_ = Exception;
    cached_exception_ =
      std::make_shared<art::Exception>(errors::BadExceptionType, "std::string");
    *cached_exception_ << "A std::string thrown as an exception occurred "
                          "during a call to the module ";
    detail::exceptionContext(md_, p, *cached_exception_)
      << "and cannot be repropagated.\n"
      << "Previous information:\n string = " << s;
    throw *cached_exception_;
  }
  catch (char const* c) {
    counts.template increment<stats::ExceptionThrown>();
    state_ = Exception;
    cached_exception_ = std::make_shared<art::Exception>(
      errors::BadExceptionType, "const char *");
    *cached_exception_ << "A const char* thrown as an exception occurred "
                          "during a call to the module ";
    detail::exceptionContext(md_, p, *cached_exception_)
      << "and cannot be repropagated.\n"
      << "Previous information:\n const char* = " << c << "\n";
    throw *cached_exception_;
  }
  catch (...) {
    counts.template increment<stats::ExceptionThrown>();
    state_ = Exception;
    cached_exception_ =
      std::make_shared<art::Exception>(errors::Unknown, "repeated");
    *cached_exception_
      << "An unknown occurred during a previous call to the module ";
    detail::exceptionContext(md_, p, *cached_exception_)
      << "and cannot be repropagated.\n";
    throw *cached_exception_;
  }

  return rc;
}

void art::Worker::endJob ( )

inherited

Definition at line 68 of file Worker.cc.

References art::Worker::actReg_, art::errors::BadExceptionType, art::Worker::description(), e, art::Worker::implEndJob(), art::Worker::md_, art::errors::OtherArt, s, art::errors::StdException, art::errors::Unknown, and art::Worker::workerType().

Referenced by art::EndPathExecutor::endJob(), and art::Schedule::endJob().

                      {
  assert(actReg_.get() != nullptr);
  actReg_->sPreModuleEndJob.invoke(md_);
  implEndJob();
  actReg_->sPostModuleEndJob.invoke(md_);
}
catch (cet::exception& e) {
  LogError("EndJob") << "A cet::exception is going through " << workerType()
                     << ":\n";

  // should event id be included?
  e << "A cet::exception is going through " << workerType() << ":\n"
    << description();
  throw art::Exception(errors::OtherArt, std::string(), e);
}
catch (std::bad_alloc& e) {
  LogError("EndJob") << "A std::bad_alloc is going through " << workerType()
                     << ":\n"
                     << description() << "\n";
  throw;
}
catch (std::exception& e) {
  LogError("EndJob") << "An std::exception is going through " << workerType()
                     << ":\n"
                     << description() << "\n";
  throw art::Exception(errors::StdException)
    << "A std::exception is going through " << workerType() << ":\n"
    << description() << "\n"
    << e.what();
}
catch (std::string& s) {
  LogError("EndJob") << "module caught an std::string during endJob\n";

  throw art::Exception(errors::BadExceptionType)
    << "std::string = " << s << "\n"
    << description() << "\n";
}
catch (char const* c) {
  LogError("EndJob") << "module caught an const char* during endJob\n";

  throw art::Exception(errors::BadExceptionType) << "cstring = " << c << "\n"
                                                 << description() << "\n";
}
catch (...) {
  LogError("EndJob") << "An unknown Exception occurred in\n"
                     << description() << "\n";
  throw art::Exception(errors::Unknown) << "An unknown Exception occurred in\n"
                                        << description() << "\n";
}

Granularity art::OutputWorker::fileGranularity

(

)

const

Definition at line 121 of file OutputWorker.cc.

References art::OutputModule::fileGranularity(), and art::WorkerT< OutputModule >::module().

  {
    return module().fileGranularity();
  }

bool art::OutputWorker::fileIsOpen

(

)

const

Definition at line 85 of file OutputWorker.cc.

References art::OutputModule::fileIsOpen(), and art::WorkerT< OutputModule >::module().

  {
    return module().fileIsOpen();
  }

void art::OutputWorker::incrementInputFileNumber

(

)

Definition at line 36 of file OutputWorker.cc.

References art::OutputModule::incrementInputFileNumber(), and art::WorkerT< OutputModule >::module().

  {
    return module().incrementInputFileNumber();
  }

std::string const& art::Worker::label ( ) const

inlineinherited

Definition at line 127 of file Worker.h.

References art::Worker::implBeginJob(), art::Worker::implDoBegin(), art::Worker::implDoEnd(), art::Worker::implDoProcess(), art::Worker::implEndJob(), art::Worker::md_, art::ModuleDescription::moduleLabel(), and art::Worker::workerType().

Referenced by art::EndPathExecutor::closeAllOutputFiles(), art::EndPathExecutor::openAllOutputFiles(), and OutputWorker().

  {
    return md_.moduleLabel();
  }

std::string const & art::OutputWorker::lastClosedFileName

(

)

const

Definition at line 22 of file OutputWorker.cc.

References art::OutputModule::lastClosedFileName(), and art::WorkerT< OutputModule >::module().

Referenced by art::EndPathExecutor::closeAllOutputFiles(), and closeFile().

  {
    return module().lastClosedFileName();
  }

bool art::OutputWorker::limitReached

(

)

const

Definition at line 103 of file OutputWorker.cc.

References art::OutputModule::limitReached(), and art::WorkerT< OutputModule >::module().

  {
    return module().limitReached();
  }

bool art::WorkerT< OutputModule >::modifiesEvent ( ) const

inlineoverridevirtualinherited

Implements art::Worker.

Definition at line 32 of file WorkerT.h.

References art::WorkerT< T >::module_.

    {
      return module_->modifiesEvent();
    }

OutputModule & art::WorkerT< OutputModule >::module ( )

inlineprotectedinherited

Definition at line 39 of file WorkerT.h.

References art::WorkerT< T >::module_.

Referenced by closeFile(), configure(), fileGranularity(), fileIsOpen(), incrementInputFileNumber(), lastClosedFileName(), limitReached(), openFile(), requestsToCloseFile(), selectProducts(), setFileStatus(), setRunAuxiliaryRangeSetID(), setSubRunAuxiliaryRangeSetID(), wantAllEvents(), writeEvent(), writeRun(), and writeSubRun().

    {
      return *module_;
    }

OutputModule const& art::WorkerT< OutputModule >::module ( ) const

inlineprotectedinherited

Definition at line 44 of file WorkerT.h.

References fb(), art::WorkerT< T >::implBeginJob(), art::WorkerT< T >::implDoBegin(), art::WorkerT< T >::implDoEnd(), art::WorkerT< T >::implDoProcess(), art::WorkerT< T >::implEndJob(), art::WorkerT< T >::implRespondToCloseInputFile(), art::WorkerT< T >::implRespondToCloseOutputFiles(), art::WorkerT< T >::implRespondToOpenInputFile(), art::WorkerT< T >::implRespondToOpenOutputFiles(), art::WorkerT< T >::module_, and art::WorkerT< T >::workerType().

    {
      return *module_;
    }

void art::OutputWorker::openFile

(

FileBlock const &

fb

)

Definition at line 48 of file OutputWorker.cc.

References ci_, art::Worker::description(), art::OutputModule::doOpenFile(), and art::WorkerT< OutputModule >::module().

Referenced by art::EndPathExecutor::openAllOutputFiles().

  {
    module().doOpenFile(fb);
    ci_->outputFileOpened(description().moduleLabel());
  }

bool art::OutputWorker::requestsToCloseFile

(

)

const

Definition at line 42 of file OutputWorker.cc.

References art::WorkerT< OutputModule >::module(), and art::OutputModule::requestsToCloseFile().

  {
    return module().requestsToCloseFile();
  }

void art::Worker::reset ( void  )

inlineinherited

Definition at line 68 of file Worker.h.

References art::Worker::Ready, and art::Worker::state_.

  {
    state_ = Ready;
  }

void art::Worker::respondToCloseInputFile ( FileBlock const &  fb )

inherited

Definition at line 128 of file Worker.cc.

References art::Worker::actReg_, art::Worker::implRespondToCloseInputFile(), and art::Worker::md_.

{
  assert(actReg_.get() != nullptr);
  actReg_->sPreModuleRespondToCloseInputFile.invoke(md_);
  implRespondToCloseInputFile(fb);
  actReg_->sPostModuleRespondToCloseInputFile.invoke(md_);
}

void art::Worker::respondToCloseOutputFiles ( FileBlock const &  fb )

inherited

Definition at line 146 of file Worker.cc.

References art::Worker::actReg_, art::Worker::implRespondToCloseOutputFiles(), and art::Worker::md_.

{
  assert(actReg_.get() != nullptr);
  actReg_->sPreModuleRespondToCloseOutputFiles.invoke(md_);
  implRespondToCloseOutputFiles(fb);
  actReg_->sPostModuleRespondToCloseOutputFiles.invoke(md_);
}

void art::Worker::respondToOpenInputFile ( FileBlock const &  fb )

inherited

Definition at line 119 of file Worker.cc.

References art::Worker::actReg_, art::Worker::implRespondToOpenInputFile(), and art::Worker::md_.

{
  assert(actReg_.get() != nullptr);
  actReg_->sPreModuleRespondToOpenInputFile.invoke(md_);
  implRespondToOpenInputFile(fb);
  actReg_->sPostModuleRespondToOpenInputFile.invoke(md_);
}

void art::Worker::respondToOpenOutputFiles ( FileBlock const &  fb )

inherited

Definition at line 137 of file Worker.cc.

References art::Worker::actReg_, art::Worker::implRespondToOpenOutputFiles(), and art::Worker::md_.

{
  assert(actReg_.get() != nullptr);
  actReg_->sPreModuleRespondToOpenOutputFiles.invoke(md_);
  implRespondToOpenOutputFiles(fb);
  actReg_->sPostModuleRespondToOpenOutputFiles.invoke(md_);
}

void art::OutputWorker::selectProducts ( ProductList const &  productList )

virtual

Definition at line 115 of file OutputWorker.cc.

References art::WorkerT< OutputModule >::module(), and art::OutputModule::selectProducts().

  {
    module().selectProducts(productList);
  }

void art::Worker::setActivityRegistry ( cet::exempt_ptr< ActivityRegistry >  areg )

inherited

The signals are required to live longer than the last call to 'doWork' this was done to improve performance based on profiling

Definition at line 12 of file Worker.cc.

References art::Worker::actReg_.

Referenced by art::Worker::descPtr().

{
  actReg_ = std::move(areg);
}

void art::OutputWorker::setFileStatus

(

OutputFileStatus

ofs

)

Definition at line 91 of file OutputWorker.cc.

References art::WorkerT< OutputModule >::module(), and art::OutputModule::setFileStatus().

  {
    return module().setFileStatus(ofs);
  }

void art::OutputWorker::setRunAuxiliaryRangeSetID

(

RangeSet const &

rs

)

Definition at line 73 of file OutputWorker.cc.

References art::OutputModule::doSetRunAuxiliaryRangeSetID(), and art::WorkerT< OutputModule >::module().

  {
    module().doSetRunAuxiliaryRangeSetID(rs);
  }

void art::OutputWorker::setSubRunAuxiliaryRangeSetID

(

RangeSet const &

rs

)

Definition at line 79 of file OutputWorker.cc.

References art::OutputModule::doSetSubRunAuxiliaryRangeSetID(), and art::WorkerT< OutputModule >::module().

  {
    module().doSetSubRunAuxiliaryRangeSetID(rs);
  }

State art::Worker::state ( ) const

inlineinherited

Definition at line 119 of file Worker.h.

References art::Worker::modifiesEvent(), and art::Worker::state_.

  {
    return state_;
  }

std::size_t art::Worker::timesExcept ( ) const

inlineinherited

Definition at line 114 of file Worker.h.

References art::Worker::counts_, and art::ExecutionCounts< ARGS >::times().

  {
    return counts_.times<stats::ExceptionThrown>();
  }

std::size_t art::Worker::timesFailed ( ) const

inlineinherited

Definition at line 109 of file Worker.h.

References art::Worker::counts_, and art::ExecutionCounts< ARGS >::times().

  {
    return counts_.times<stats::Failed>();
  }

std::size_t art::Worker::timesPassed ( ) const

inlineinherited

Definition at line 104 of file Worker.h.

References art::Worker::counts_, and art::ExecutionCounts< ARGS >::times().

  {
    return counts_.times<stats::Passed>();
  }

std::size_t art::Worker::timesRun ( ) const

inlineinherited

Definition at line 94 of file Worker.h.

References art::Worker::counts_, and art::ExecutionCounts< ARGS >::times().

  {
    return counts_.times<stats::Run>();
  }

std::size_t art::Worker::timesVisited ( ) const

inlineinherited

Definition at line 99 of file Worker.h.

References art::Worker::counts_, and art::ExecutionCounts< ARGS >::times().

  {
    return counts_.times<stats::Visited>();
  }

bool art::OutputWorker::wantAllEvents

(

)

const

Definition at line 97 of file OutputWorker.cc.

References art::WorkerT< OutputModule >::module(), and art::EventObserverBase::wantAllEvents().

  {
    return module().wantAllEvents();
  }

void art::OutputWorker::writeEvent

(

EventPrincipal &

ep

)

Definition at line 67 of file OutputWorker.cc.

References art::OutputModule::doWriteEvent(), and art::WorkerT< OutputModule >::module().

  {
    module().doWriteEvent(srp);
  }

void art::OutputWorker::writeRun

(

RunPrincipal &

rp

)

Definition at line 55 of file OutputWorker.cc.

References art::OutputModule::doWriteRun(), and art::WorkerT< OutputModule >::module().

  {
    module().doWriteRun(rp);
  }

void art::OutputWorker::writeSubRun

(

SubRunPrincipal &

srp

)

Definition at line 61 of file OutputWorker.cc.

References art::OutputModule::doWriteSubRun(), and art::WorkerT< OutputModule >::module().

  {
    module().doWriteSubRun(srp);
  }

Member Data Documentation

ServiceHandle<CatalogInterface> art::OutputWorker::ci_

private

Definition at line 66 of file OutputWorker.h.

Referenced by closeFile(), openFile(), and OutputWorker().

Granularity art::OutputWorker::fileGranularity_ {Granularity::Unset}

private

Definition at line 67 of file OutputWorker.h.

---

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

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