EL::Worker Class Reference

#include <Worker.h>

Inheritance diagram for EL::Worker:

Collaboration diagram for EL::Worker:

Public Member Functions
void	testInvariant () const
	effects: test the invariant of this object guarantee: no-fail
virtual	~Worker ()
	effects: standard destructor guarantee: no-fail
void	addOutput (TObject *output_swallow) final override
	effects: add an object to the output.
void	addOutputList (const std::string &name, TObject *output_swallow) override
	effects: add a given object to the output.
TObject *	getOutputHist (const std::string &name) const final override
	get the output histogram with the given name
TFile *	getOutputFile (const std::string &label) const override
	effects: get the output file that goes into the dataset with the given label.
TFile *	getOutputFileNull (const std::string &label) const override
	effects: get the output file that goes into the dataset with the given label.
::StatusCode	addTree (const TTree &tree, const std::string &stream) final override
	effects: adds a tree to an output file specified by the stream/label failures: Incorrect stream/label specified, called at the wrong time note: See getOutputFile for failure types...
TTree *	getOutputTree (const std::string &name, const std::string &stream) const final override
	effects: get the tree that was added to an output file earlier failures: Tree doesn't exist
const SH::MetaObject *	metaData () const override
	description: the sample meta-data we are working on guarantee: no-fail invariant: metaData != 0 rationale: this can be used for accessing sample meta-data
TTree *	tree () const override
	description: the tree we are running on guarantee: no-fail
Long64_t	treeEntry () const override
	description: the entry in the tree we are reading guarantee: no-fail
TFile *	inputFile () const override
	description: the file we are reading the current tree from guarantee: no-fail
bool	hasInputEvents () const override
	flag whether the most recently opened input file has events or not
std::string	inputFileName () const override
	the name of the file we are reading the current tree from, without the path component
TTree *	triggerConfig () const override
	description: the trigger config tree from the input file, or NULL if we did not find it guarantee: strong failures: i/o errors
xAOD::Event *	xaodEvent () const override
	description: the xAOD event and store guarantee: strong failures: out of memory I failures: EventSvc not configured postcondition: result != 0
xAOD::TStore *	xaodStore () const override
EL::Algorithm *	getAlg (const std::string &name) const override
	effects: returns the algorithms with the given name or NULL if there is none guarantee: strong failures: out of memory II
void	skipEvent () override
	effects: skip the current event, i.e.
virtual bool	filterPassed () const noexcept final override
	whether the current algorithm passed its filter criterion for the current event
virtual void	setFilterPassed (bool val_filterPassed) noexcept final override
	set the value of filterPassed
	Worker ()
	standard constructor
::StatusCode	directExecute (const SH::Sample &sample, const Job &job, const std::string &location, const SH::MetaObject &options)
	run the job
::StatusCode	batchExecute (unsigned job_id, const char *confFile)
	effects: do what is needed to execute the given job segment guarantee: basic failures: job specific
::StatusCode	gridExecute (const std::string &sampleName, Long64_t SkipEvents, Long64_t nEventsPerJob)

Protected Member Functions
void	setMetaData (const SH::MetaObject *val_metaData)
	set the metaData
void	setOutputHist (const std::string &val_outputTarget)
	set the histogram output list
void	setSegmentName (const std::string &val_segmentName)
	set the segment name
void	setJobConfig (JobConfig &&jobConfig)
	set the JobConfig
::StatusCode	initialize ()
	initialize the worker
::StatusCode	processInputs ()
	process all the inputs
::StatusCode	finalize ()
	finalize the worker
::StatusCode	processEvents (EventRange &eventRange) override
	process the given event range
::StatusCode	openInputFile (const std::string &inputFileUrl) override
	open the given input file without processing it
::StatusCode	addOutputStream (const std::string &label, Detail::OutputStreamData output)
	effects: add another output file guarantee: strong failures: low level errors II failures: label already used
Long64_t	inputFileNumEntries () const override
	the number of events in the input file
uint64_t	eventsProcessed () const noexcept
	the number of events that have been processed

Private Types
enum	GridErrorCodes { EC_FAIL = 220 , EC_ABORT = 221 , EC_NOTFINISHED = 222 , EC_BADINPUT = 223 }

Private Member Functions
void	addOutput (std::unique_ptr< TObject > output)
	add the given output object to the histogram output stream

Static Private Member Functions
static bool	fileOpenErrorFilter (int level, bool, const char *, const char *)
	Error handler for file opening.

Private Attributes
std::vector< std::unique_ptr< Detail::Module > >	m_modules
	the list of modules we hold
bool	m_firstInputFile {true}
	whether this is the first input file
bool	m_newInputFile {false}
	whether this is a new input file (i.e.
std::string	m_outputTarget
	the target file to which we will write the histogram output
std::string	m_segmentName
	the name of the segment we are processing
bool	m_algorithmsInitialized {false}
	whether the algorithms are initialized
bool	m_firstEvent {true}
	whether we are still to process the first event
std::vector< asg::AsgComponentConfig >	m_moduleConfig
	the module configurations we use
std::vector< Detail::AlgorithmData >	m_algs
	the list of algorithms
std::string	m_inputFileUrl
	the input file url of the currently opened file
std::unique_ptr< TFile >	m_inputFile
	the input file pointer of the currently opened filed
TTree *	m_inputTree {nullptr}
	the (main) tree in the input file
uint64_t	m_inputEntry {0}
	the entry in the input tree we are currently looking at
bool	m_hasInputEvents = false
	flag whether the most recently opened input file has events or not
bool	m_skipEvent = false
	whether we are skipping the current event
const SH::MetaObject *	m_metaData {nullptr}
	the meta-data we use
uint64_t	m_eventsProcessed {0}
	the number of events that have been processed
OutputStreamData *	m_histOutput {nullptr}
	the histogram output stream
std::unique_ptr< TTree >	m_jobStats
	Tree saving per-job statistics information.
xAOD::Event *	m_event {nullptr}
	the Event object, if we use one
xAOD::TStore *	m_tstore {nullptr}
	the TStore structure, if we use one
asg::SgEvent *	m_evtStore {nullptr}
	the SgEvent structure, if we use one
Worker *	m_worker {nullptr}
	the worker (to pass on to the algorithms)
std::map< std::string, std::shared_ptr< Detail::OutputStreamData > >	m_outputs
	the list of output files
BatchJob *	m_batchJob = nullptr
	the BatchJob configuration (if used)

Detailed Description

Definition at line 21 of file Worker.h.

Member Enumeration Documentation

GridErrorCodes

enum EL::Worker::GridErrorCodes

private

Enumerator
EC_FAIL
EC_ABORT
EC_NOTFINISHED
EC_BADINPUT

Definition at line 252 of file Worker.h.

                        {
      EC_FAIL = 220,
      EC_ABORT = 221,
      EC_NOTFINISHED = 222,
      EC_BADINPUT = 223
    };

Constructor & Destructor Documentation

~Worker()

EL::Worker::~Worker ( )

virtual

effects: standard destructor guarantee: no-fail

Definition at line 79 of file Worker.cxx.

  {
    RCU_DESTROY_INVARIANT (this);
  }

Worker()

EL::Worker::Worker

(

)

standard constructor

Guarantee

strong

Failures

out of memory I

Definition at line 332 of file Worker.cxx.

  {
    m_worker = this;
 
    RCU_NEW_INVARIANT (this);
  }

Member Function Documentation

addOutput() [1/2]

void EL::Detail::ModuleData::addOutput ( std::unique_ptr< TObject > output )

inherited

add the given output object to the histogram output stream

Guarantee

basic

Failures

out of memory II

Definition at line 33 of file ModuleData.cxx.

    {
      RCU_ASSERT (m_histOutput != nullptr);
      m_histOutput->addOutput (std::move (output));
    }

addOutput() [2/2]

void EL::Worker::addOutput ( TObject * output_swallow )

finaloverridevirtual

effects: add an object to the output.

the worker takes over ownership of the object, but the caller may maintain a reference to it guarantee: basic, argument is always swallowed failures: out of memory I requires: output_swallow != 0 warning: so far I placed no requirements on the output objects. I may do that at a later stage though, possibly breaking existing code.

Implements EL::IHistogramWorker.

Definition at line 87 of file Worker.cxx.

  {
    std::unique_ptr<TObject> output (output_swallow);
 
    RCU_CHANGE_INVARIANT (this);
    RCU_REQUIRE_SOFT (output_swallow != 0);
 
    RCU::SetDirectory (output_swallow, 0);
    ModuleData::addOutput (std::move (output));
  }

addOutputList()

void EL::Worker::addOutputList ( const std::string & name, TObject * output_swallow )

overridevirtual

effects: add a given object to the output.

instead of trying to merge the outputs from multiple jobs the output file will contain a TList of the given name with the objects from all the output. guarantee: basic, argument is always swallowed failures: out of memory II requires: output_swallow != 0 rationale: This was primarily build to allow the GRL output to be collected from EventLoop jobs, but it can be used for any kind of output that can not or should not be merged.

Implements EL::IWorker.

Definition at line 101 of file Worker.cxx.

  {
    std::unique_ptr<TObject> output (output_swallow);
 
    RCU_CHANGE_INVARIANT (this);
    RCU_REQUIRE_SOFT (output_swallow != 0);
 
    RCU::SetDirectory (output_swallow, 0);
    std::unique_ptr<TList> list (new TList);
    list->SetName (name.c_str());
    list->Add (output.release());
    addOutput (list.release());
  }

addOutputStream()

StatusCode EL::Worker::addOutputStream ( const std::string & label, Detail::OutputStreamData output )

protected

effects: add another output file guarantee: strong failures: low level errors II failures: label already used

Definition at line 765 of file Worker.cxx.

  {
    using namespace msgEventLoop;
    RCU_CHANGE_INVARIANT (this);
 
    if (m_outputs.find (label) != m_outputs.end())
    {
      ANA_MSG_ERROR ("output file already defined for label: " + label);
      return ::StatusCode::FAILURE;
    }
    if (data.file() == nullptr)
    {
      ANA_MSG_ERROR ("output stream does not have a file attached");
      return ::StatusCode::FAILURE;
    }
    if (data.mainStreamName().empty())
      data.setMainStreamName (label);
    m_outputs.insert (std::make_pair (label, std::make_shared<Detail::OutputStreamData>(std::move (data))));
    return ::StatusCode::SUCCESS;
  }

addTree()

StatusCode EL::Worker::addTree ( const TTree & tree, const std::string & stream )

finaloverridevirtual

effects: adds a tree to an output file specified by the stream/label failures: Incorrect stream/label specified, called at the wrong time note: See getOutputFile for failure types...

Implements EL::ITreeWorker.

Definition at line 154 of file Worker.cxx.

  {
    using namespace msgEventLoop;
    RCU_READ_INVARIANT( this );
 
    auto outputIter = m_outputs.find (stream);
    if (outputIter == m_outputs.end())
    {
      ANA_MSG_ERROR ( "No output file with stream name \"" + stream +
                      "\" found" );
      return ::StatusCode::FAILURE;
    }
 
    outputIter->second->addClone (tree);
 
    // Return gracefully:
    return ::StatusCode::SUCCESS;
  }

batchExecute()

StatusCode EL::Worker::batchExecute	(	unsigned	job_id,
		const char *	confFile )

effects: do what is needed to execute the given job segment guarantee: basic failures: job specific

Definition at line 864 of file Worker.cxx.

  {
    using namespace msgEventLoop;
    RCU_CHANGE_INVARIANT (this);
 
    try
    {
      std::unique_ptr<TFile> file (TFile::Open (confFile, "READ"));
      if (file.get() == nullptr || file->IsZombie())
      {
        ANA_MSG_ERROR ("failed to open file: " << confFile);
        return ::StatusCode::FAILURE;
      }
 
      std::unique_ptr<BatchJob> job (dynamic_cast<BatchJob*>(file->Get ("job")));
      m_batchJob = job.get();
      if (job.get() == nullptr)
      {
        ANA_MSG_ERROR ("failed to retrieve BatchJob object");
        return ::StatusCode::FAILURE;
      }
 
      if (job_id >= job->segments.size())
      {
        ANA_MSG_ERROR ("invalid job-id " << job_id << ", max is " << job->segments.size());
        return ::StatusCode::FAILURE;
      }
      BatchSegment *segment = &job->segments[job_id];
      RCU_ASSERT (segment->job_id == job_id);
      RCU_ASSERT (segment->sample < job->samples.size());
      BatchSample *sample = &job->samples[segment->sample];
 
      gSystem->Exec ("pwd");
      gSystem->MakeDirectory ("output");
 
      setMetaData (&sample->meta);
      setOutputHist (job->location + "/fetch");
      setSegmentName (segment->fullName);
 
      setJobConfig (JobConfig (job->job.jobConfig()));
 
      for (Job::outputIter out = job->job.outputBegin(),
             end = job->job.outputEnd(); out != end; ++ out)
      {
        Detail::OutputStreamData data {
          out->output()->makeWriter (segment->sampleName, segment->segmentName, ".root")};
        ANA_CHECK (addOutputStream (out->label(), std::move (data)));
      }
 
      {
        m_moduleConfig.emplace_back ("EL::Detail::BatchInputModule/BatchInputModule");
        ANA_CHECK (m_moduleConfig.back().setProperty ("jobId", job_id));
        Long64_t maxEvents = metaData()->castDouble (Job::optMaxEvents, -1);
        if (maxEvents != -1)
          ANA_CHECK (m_moduleConfig.back().setProperty ("maxEvents", maxEvents));
      }
 
      ANA_CHECK (initialize ());
      ANA_CHECK (processInputs ());
      ANA_CHECK (finalize ());
 
      // m_batchJob and the metadata pointer refer into the local `job`,
      // which is destroyed when this function returns; clear them now that
      // all the processing that consumes them is done.
      m_batchJob = nullptr;
      setMetaData (nullptr);
 
      std::ostringstream job_name;
      job_name << job_id;
      const std::string completedName (job->location + "/status/completed-" + job_name.str());
      std::ofstream completed (completedName.c_str());
      if (!completed)
      {
        ANA_MSG_ERROR ("failed to write completion marker " << completedName);
        return ::StatusCode::FAILURE;
      }
      return ::StatusCode::SUCCESS;
    } catch (...)
    {
      m_batchJob = nullptr;
      setMetaData (nullptr);
      Detail::report_exception (std::current_exception());
      return ::StatusCode::FAILURE;
    }
  }

directExecute()

StatusCode EL::Worker::directExecute	(	const SH::Sample &	sample,
		const Job &	job,
		const std::string &	location,
		const SH::MetaObject &	options )

run the job

Guarantee

basic

Definition at line 816 of file Worker.cxx.

  {
    using namespace msgEventLoop;
    RCU_CHANGE_INVARIANT (this);
 
    SH::MetaObject meta (*sample.meta());
    meta.fetchDefaults (options);
 
    setMetaData (&meta);
    setOutputHist (location);
    setSegmentName (sample.name());
 
    ANA_MSG_INFO ("Running sample: " << sample.name());
 
    setJobConfig (JobConfig (job.jobConfig()));
 
    for (Job::outputIter out = job.outputBegin(),
           end = job.outputEnd(); out != end; ++ out)
    {
      Detail::OutputStreamData data {
        out->output()->makeWriter (sample.name(), "", ".root")};
      ANA_CHECK (addOutputStream (out->label(), std::move (data)));
    }
 
    {
      m_moduleConfig.emplace_back ("EL::Detail::DirectInputModule/DirectInputModule");
      ANA_CHECK (m_moduleConfig.back().setProperty ("fileList", sample.makeFileList()));
      Long64_t maxEvents = metaData()->castDouble (Job::optMaxEvents, -1);
      if (maxEvents != -1)
        ANA_CHECK (m_moduleConfig.back().setProperty ("maxEvents", maxEvents));
      Long64_t skipEvents = metaData()->castDouble (Job::optSkipEvents, 0);
      if (skipEvents != 0)
        ANA_CHECK (m_moduleConfig.back().setProperty ("skipEvents", skipEvents));
    }
 
    ANA_CHECK (initialize ());
    ANA_CHECK (processInputs ());
    ANA_CHECK (finalize ());
    // the metadata pointer refers to the local `meta`, which is destroyed
    // when this function returns; clear it now that processing is done
    setMetaData (nullptr);
    return ::StatusCode::SUCCESS;
  }

eventsProcessed()

uint64_t EL::Worker::eventsProcessed ( ) const

protectednoexcept

the number of events that have been processed

Guarantee

no-fail

Definition at line 807 of file Worker.cxx.

  {
    RCU_READ_INVARIANT (this);
    return m_eventsProcessed;
  }

fileOpenErrorFilter()

bool EL::Worker::fileOpenErrorFilter ( int level, bool , const char * s1, const char * s2 )

staticprivate

Error handler for file opening.

Definition at line 645 of file Worker.cxx.

  {
    // Don't fail on missing dictionary messages.
    if (strstr (s2, "no streamer or dictionary") != nullptr) {
      return true;
    }
 
    // For messages above warning level (SysError, Error, Fatal)
    if( level > kWarning ) {
      // We won't output further; ROOT should have already put something in the log file
      std::string msg = "ROOT error detected in Worker.cxx: ";
      msg += s1;
      msg += " ";
      msg += s2;
      throw std::runtime_error(msg);
    }
 
    // Pass to the default error handlers
    return true;
  }

filterPassed()

bool EL::Worker::filterPassed ( ) const

finaloverridevirtualnoexcept

whether the current algorithm passed its filter criterion for the current event

Guarantee

no-fail

Implements EL::IFilterWorker.

Definition at line 314 of file Worker.cxx.

  {
    RCU_READ_INVARIANT (this);
    return !m_skipEvent;
  }

finalize()

StatusCode EL::Worker::finalize ( )

protected

finalize the worker

This method ought to be called after all events have been processed. It is meant to ensure that the job is ended properly and all outputs are written out and files are closed.

Guarantee

basic

Failures

finalization failures

Definition at line 514 of file Worker.cxx.

  {
    using namespace msgEventLoop;
 
    RCU_CHANGE_INVARIANT (this);
 
    if (m_algorithmsInitialized == false)
    {
      ANA_MSG_ERROR ("algorithms never got initialized");
      return StatusCode::FAILURE;
    }
 
    ANA_CHECK (openInputFile (""));
    for (auto& module : m_modules)
      ANA_CHECK (module->onFinalize (*this));
    for (auto& output : m_outputs)
    {
      if (output.first != Job::histogramStreamName && output.second->mainStreamName() == output.first)
      {
        output.second->saveOutput ();
        output.second->close ();
        std::string path = output.second->finalFileName ();
        if (!path.empty())
          addOutputList ("EventLoop_OutputStream_" + output.first, new TObjString (path.c_str()));
      }
    }
    for (auto& module : m_modules)
      ANA_CHECK (module->postFinalize (*this));
    if (m_jobStats->GetListOfBranches()->GetEntries() > 0)
    {
      if (m_jobStats->Fill() <= 0)
      {
        ANA_MSG_ERROR ("failed to fill the job statistics tree");
        return ::StatusCode::FAILURE;
      }
      ModuleData::addOutput (std::move (m_jobStats));
    }
    m_histOutput->saveOutput ();
    for (auto& module : m_modules)
      ANA_CHECK (module->onWorkerEnd (*this));
    m_histOutput->saveOutput ();
    m_histOutput->close ();
 
    for (auto& module : m_modules){
      ANA_CHECK (module->postFileClose(*this));
    }
    ANA_MSG_INFO ("worker finished successfully");
    return ::StatusCode::SUCCESS;
  }

getAlg()

Algorithm * EL::Worker::getAlg ( const std::string & name ) const

overridevirtual

effects: returns the algorithms with the given name or NULL if there is none guarantee: strong failures: out of memory II

Implements EL::IWorker.

Definition at line 291 of file Worker.cxx.

  {
    RCU_READ_INVARIANT (this);
    for (auto& alg : m_algs)
    {
      if (alg->hasName (name))
    return alg.m_algorithm->getLegacyAlg();
    }
    return 0;
  }

getOutputFile()

TFile * EL::Worker::getOutputFile ( const std::string & label ) const

overridevirtual

effects: get the output file that goes into the dataset with the given label.

this dataset has to be registered before the job is submitted. typically that happens in the doSetupJob method. guarantee: strong failures: no dataset with the given label postcondition: result != 0 note: the default value for the argument corresponds to the default label value in the OutputInfo class.

Implements EL::IWorker.

Definition at line 130 of file Worker.cxx.

  {
    RCU_READ_INVARIANT (this);
    TFile *result = getOutputFileNull (label);
    if (result == 0)
      throw std::runtime_error ("no output dataset defined with label: " + label);
    return result;
  }

getOutputFileNull()

TFile * EL::Worker::getOutputFileNull ( const std::string & label ) const

overridevirtual

effects: get the output file that goes into the dataset with the given label.

this dataset has to be registered before the job is submitted. typically that happens in the doSetupJob method. guarantee: strong failures: internal errors note: the default value for the argument corresponds to the default label value in the OutputInfo class. rationale: this method was added to support optional output files, i.e.: the algorithm leaves it to the user whether or not the output file gets configured. then the algorithm just checks whether the output file is there. if so it fills it, otherwise it ignores it.

Implements EL::IWorker.

Definition at line 142 of file Worker.cxx.

  {
    RCU_READ_INVARIANT (this);
    auto iter = m_outputs.find (label);
    if (iter == m_outputs.end())
      return 0;
    return iter->second->file();
  }

getOutputHist()

TObject * EL::Worker::getOutputHist ( const std::string & name ) const

finaloverridevirtual

get the output histogram with the given name

This is mostly meant, so that I can emulate the Athena histogram mechanism.

Guarantee

strong

Failures

object not found

Postcondition

result != 0

Implements EL::IHistogramWorker.

Definition at line 118 of file Worker.cxx.

  {
    RCU_READ_INVARIANT (this);
 
    TObject *result = m_histOutput->getOutputHist (name);
    if (result == nullptr) throw std::runtime_error ("unknown output histogram: " + name);
    return result;
  }

getOutputTree()

TTree * EL::Worker::getOutputTree ( const std::string & name, const std::string & stream ) const

finaloverridevirtual

effects: get the tree that was added to an output file earlier failures: Tree doesn't exist

Implements EL::ITreeWorker.

Definition at line 176 of file Worker.cxx.

  {
    using namespace msgEventLoop;
    RCU_READ_INVARIANT( this );
 
    auto outputIter = m_outputs.find (stream);
    if (outputIter == m_outputs.end())
    {
      throw std::runtime_error ("No output file with stream name \"" + stream + "\" found");
    }
 
    TTree *result = outputIter->second->getOutputTree( name );
    if( result == nullptr ) {
      throw std::runtime_error ("No tree with name \"" + name + "\" in stream \"" + stream + "\"");
    }
    return result;
  }

gridExecute()

StatusCode EL::Worker::gridExecute	(	const std::string &	sampleName,
		Long64_t	SkipEvents,
		Long64_t	nEventsPerJob )

Definition at line 953 of file Worker.cxx.

  {
    using namespace msgEventLoop;
    RCU_CHANGE_INVARIANT (this);
 
    ANA_MSG_INFO ("Running with ROOT version " << gROOT->GetVersion()
                  << " (" << gROOT->GetVersionDate() << ")");
 
    ANA_MSG_INFO ("Loading EventLoop grid job");
 
 
    TList bigOutputs;
    std::unique_ptr<JobConfig> jobConfig;
    SH::MetaObject *mo = 0;
 
    std::unique_ptr<TFile> f (TFile::Open("jobdef.root"));
    if (f == nullptr || f->IsZombie()) {
      ANA_MSG_ERROR ("Could not read jobdef");
      return ::StatusCode::FAILURE;
    }
 
    mo = dynamic_cast<SH::MetaObject*>(f->Get(sampleName.c_str()));
    if (!mo)
      mo = dynamic_cast<SH::MetaObject*>(f->Get("defaultMetaObject"));
    if (!mo) {
      ANA_MSG_ERROR ("Could not read in sample meta object");
      return ::StatusCode::FAILURE;
    }
 
    jobConfig.reset (dynamic_cast<JobConfig*>(f->Get("jobConfig")));
    if (jobConfig == nullptr)
    {
      ANA_MSG_ERROR ("failed to read jobConfig object");
      return ::StatusCode::FAILURE;
    }
 
    {
      std::unique_ptr<TList> outs ((TList*)f->Get("outputs"));
      if (outs == nullptr)
      {
        ANA_MSG_ERROR ("Could not read list of outputs");
        return ::StatusCode::FAILURE;
      }
 
      TIter itr(outs.get());
      TObject *obj = 0;
      while ((obj = itr())) {
        EL::OutputStream * out = dynamic_cast<EL::OutputStream*>(obj);
        if (out) {
          bigOutputs.Add(out);
        }
        else {
          ANA_MSG_ERROR ("Encountered unexpected entry in list of outputs");
          return ::StatusCode::FAILURE;
        }
      }
    }
 
    f->Close();
    f.reset ();
 
    const std::string location = ".";
 
    mo->setBool (Job::optGridReporting, true);
    setMetaData (mo);
    setOutputHist (location);
    setSegmentName ("output");
 
    ANA_MSG_INFO ("Starting EventLoop Grid worker");
 
    {//Create and register the "big" output files with base class
      TIter itr(&bigOutputs);
      TObject *obj = 0;
      while ((obj = itr())) {
        EL::OutputStream *os = dynamic_cast<EL::OutputStream*>(obj);
        if (os == nullptr)
        {
          ANA_MSG_ERROR ("Bad input");
          return ::StatusCode::FAILURE;
        }
        {
          Detail::OutputStreamData data {
            location + "/" + os->label() + ".root", "RECREATE"};
          ANA_CHECK (addOutputStream (os->label(), std::move (data)));
        }
      }
    }
 
    setJobConfig (std::move (*jobConfig));
 
    {
      std::vector<std::string> fileList;
      std::ifstream infile("input.txt");
      while (infile) {
        std::string sLine;
        if (!getline(infile, sLine)) break;
        std::istringstream ssLine(sLine);
        while (ssLine) {
          std::string sFile;
          if (!getline(ssLine, sFile, ',')) break;
          fileList.push_back(sFile);
        }
      }
      if (fileList.size() == 0) {
        ANA_MSG_ERROR ("no input files provided");
        //User was expecting input after all.
        gSystem->Exit(EC_BADINPUT);
      }
      m_moduleConfig.emplace_back ("EL::Detail::DirectInputModule/DirectInputModule");
      ANA_CHECK (m_moduleConfig.back().setProperty ("fileList", fileList));
 
      if (nEventsPerJob != -1)
        ANA_CHECK (m_moduleConfig.back().setProperty ("maxEvents", nEventsPerJob));
      if (SkipEvents != 0)
        ANA_CHECK (m_moduleConfig.back().setProperty ("skipEvents", SkipEvents));
    }
 
    ANA_CHECK (initialize());
    ANA_CHECK (processInputs ());
    ANA_CHECK (finalize ());
 
    int nEvents = eventsProcessed();
    ANA_MSG_INFO ("Loop finished.");
    ANA_MSG_INFO ("Read/processed " << nEvents << " events.");
 
    ANA_MSG_INFO ("EventLoop Grid worker finished");
    ANA_MSG_INFO ("Saving output");
    return ::StatusCode::SUCCESS;
  }

hasInputEvents()

bool EL::Worker::hasInputEvents ( ) const

overridevirtual

flag whether the most recently opened input file has events or not

Guarantee no-fail

Implements EL::IWorker.

Definition at line 232 of file Worker.cxx.

  {
    // no invariant used
    return m_hasInputEvents;
  }

initialize()

StatusCode EL::Worker::initialize ( )

protected

initialize the worker

This method ought to be called after the options on the worker are set and before any events are processed. It is meant to make sure everything is ready and set up for event processing.

Guarantee

basic

Failures

initialization failures

Definition at line 385 of file Worker.cxx.

  {
    using namespace msgEventLoop;
    RCU_CHANGE_INVARIANT (this);
 
    const bool xAODInput = m_metaData->castBool (Job::optXAODInput, false);
 
    ANA_MSG_INFO ("xAODInput = " << xAODInput);
 
    if (metaData()->castBool (Job::optAlgorithmMemoryMonitor, false))
      m_moduleConfig.emplace_back ("EL::Detail::MemoryMonitorModule/EarlyMemoryMonitorModule");
    if (auto cacheSize = metaData()->castDouble (Job::optCacheSize, 0); cacheSize > 0)
    {
      m_moduleConfig.emplace_back ("EL::Detail::TreeCacheModule/TreeCacheModule");
      ANA_CHECK (m_moduleConfig.back().setProperty ("cacheSize", Long64_t (cacheSize)));
      ANA_CHECK (m_moduleConfig.back().setProperty ("cacheLearnEntries", Long64_t (metaData()->castInteger (Job::optCacheLearnEntries, 0))));
      ANA_CHECK (m_moduleConfig.back().setProperty ("printPerFileStats", metaData()->castBool (Job::optPrintPerFileStats, false)));
    }
    if (xAODInput)
    {
      m_moduleConfig.emplace_back ("EL::Detail::EventModule/EventModule");
      if (metaData()->castDouble (Job::optXAODSummaryReport, 1) == 0)
        ANA_CHECK (m_moduleConfig.back().setProperty ("summaryReport", false));
      ANA_CHECK (m_moduleConfig.back().setProperty ("useStats", metaData()->castBool (Job::optXAODPerfStats, false)));
    }
    auto factoryPreload = metaData()->castString (Job::optFactoryPreload, "");
    if (!factoryPreload.empty())
    {
      m_moduleConfig.emplace_back ("EL::Detail::FactoryPreloadModule/FactoryPreloadModule");
      ANA_CHECK (m_moduleConfig.back().setProperty ("preloader", factoryPreload));
    }
    m_moduleConfig.emplace_back ("EL::Detail::LeakCheckModule/LeakCheckModule");
    ANA_CHECK (m_moduleConfig.back().setProperty ("failOnLeak", metaData()->castBool (Job::optMemFailOnLeak, false)));
    ANA_CHECK (m_moduleConfig.back().setProperty ("absResidentLimit", metaData()->castInteger (Job::optMemResidentIncreaseLimit, 10000)));
    ANA_CHECK (m_moduleConfig.back().setProperty ("absVirtualLimit", metaData()->castInteger (Job::optMemVirtualIncreaseLimit, 0)));
    ANA_CHECK (m_moduleConfig.back().setProperty ("perEvResidentLimit", metaData()->castInteger (Job::optMemResidentPerEventIncreaseLimit, 10)));
    ANA_CHECK (m_moduleConfig.back().setProperty ("perEvVirtualLimit", metaData()->castInteger (Job::optMemVirtualPerEventIncreaseLimit, 0)));
    m_moduleConfig.emplace_back ("EL::Detail::StopwatchModule/StopwatchModule");
    if (metaData()->castBool (Job::optGridReporting, false))
      m_moduleConfig.emplace_back ("EL::Detail::GridReportingModule/GridReportingModule");
    if (metaData()->castBool (Job::optAlgorithmTimer, false))
      m_moduleConfig.emplace_back ("EL::Detail::AlgorithmTimerModule/AlgorithmTimerModule");
    if (metaData()->castBool (Job::optAlgorithmMemoryMonitor, false))
      m_moduleConfig.emplace_back ("EL::Detail::AlgorithmMemoryModule/AlgorithmMemoryModule");
    m_moduleConfig.emplace_back ("EL::Detail::FileExecutedModule/FileExecutedModule");
    m_moduleConfig.emplace_back ("EL::Detail::EventCountModule/EventCountModule");
    m_moduleConfig.emplace_back ("EL::Detail::WorkerConfigModule/WorkerConfigModule");
    m_moduleConfig.emplace_back ("EL::Detail::AlgorithmStateModule/AlgorithmStateModule");
    m_moduleConfig.emplace_back ("EL::Detail::PostClosedOutputsModule/PostClosedOutputsModule");
    if (metaData()->castBool (Job::optAlgorithmMemoryMonitor, false))
      m_moduleConfig.emplace_back ("EL::Detail::MemoryMonitorModule/LateMemoryMonitorModule");
 
    for (const auto& config : m_moduleConfig)
    {
      std::unique_ptr<Detail::Module> module;
      ANA_CHECK (make_module (module, config));
      m_modules.push_back (std::move (module));
    }
 
    if (m_outputs.find (Job::histogramStreamName) == m_outputs.end())
    {
      Detail::OutputStreamData data {
        m_outputTarget + "/hist-" + m_segmentName + ".root", "RECREATE"};
      ANA_CHECK (addOutputStream (Job::histogramStreamName, std::move (data)));
    }
    RCU_ASSERT (m_outputs.find (Job::histogramStreamName) != m_outputs.end());
    m_histOutput = m_outputs.at(Job::histogramStreamName).get();
    if (auto aliases = metaData()->castString (Job::optStreamAliases, ""); !aliases.empty())
    {
      // the format of aliases is "alias1=realname1,alias2=realname2"
      std::istringstream iss (aliases);
      std::string alias;
      while (std::getline (iss, alias, ','))
      {
        auto pos = alias.find ('=');
        if (pos == std::string::npos)
        {
          ANA_MSG_ERROR ("Invalid alias format: " << alias);
          return ::StatusCode::FAILURE;
        }
        auto aliasName = alias.substr (0, pos);
        auto realName = alias.substr (pos + 1);
        auto realOutput = m_outputs.find (realName);
        if (realOutput == m_outputs.end())
        {
          ANA_MSG_ERROR ("output stream " << realName << " not found for alias " << aliasName);
          return ::StatusCode::FAILURE;
        }
        auto [aliasOutput, success] = m_outputs.emplace (aliasName, realOutput->second);
        if (!success)
        {
          ANA_MSG_ERROR ("output stream " << aliasName << " already exists, can't make alias");
          return ::StatusCode::FAILURE;
        }
      }
    }
 
    m_jobStats = std::make_unique<TTree>
      ("EventLoop_JobStats", "EventLoop job statistics");
    m_jobStats->SetDirectory (nullptr);
 
    ANA_MSG_INFO ("calling firstInitialize on all modules");
    for (auto& module : m_modules)
      ANA_CHECK (module->firstInitialize (*this));
    ANA_MSG_INFO ("calling preFileInitialize on all modules");
    for (auto& module : m_modules)
      ANA_CHECK (module->preFileInitialize (*this));
    
    return ::StatusCode::SUCCESS;
  }

inputFile()

TFile * EL::Worker::inputFile ( ) const

overridevirtual

description: the file we are reading the current tree from guarantee: no-fail

Implements EL::IWorker.

Definition at line 224 of file Worker.cxx.

  {
    RCU_READ_INVARIANT (this);
    return m_inputFile.get();
  }

inputFileName()

std::string EL::Worker::inputFileName ( ) const

overridevirtual

the name of the file we are reading the current tree from, without the path component

Guarantee

no-fail

Implements EL::IWorker.

Definition at line 240 of file Worker.cxx.

  {
    // no invariant used
    if (inputFile() == nullptr)
      throw std::runtime_error ("no input file is currently open");
    std::string path = inputFile()->GetName();
    auto split = path.rfind ('/');
    if (split != std::string::npos)
      return path.substr (split + 1);
    else
      return path;
  }

inputFileNumEntries()

Long64_t EL::Worker::inputFileNumEntries ( ) const

overrideprotectedvirtual

the number of events in the input file

Guarantee

no-fail

Precondition

inputFile() != 0

Implements EL::Detail::IInputModuleActions.

Definition at line 790 of file Worker.cxx.

  {
    RCU_READ_INVARIANT (this);
    RCU_REQUIRE (inputFile() != 0);
 
    if (m_event) {
      return m_event->getEntries();
    }
    else if (m_inputTree != 0)
      return m_inputTree->GetEntries();
    else
      return 0;
  }

metaData()

const SH::MetaObject * EL::Worker::metaData ( ) const

overridevirtual

description: the sample meta-data we are working on guarantee: no-fail invariant: metaData != 0 rationale: this can be used for accessing sample meta-data

Implements EL::IWorker.

Definition at line 197 of file Worker.cxx.

  {
    RCU_READ_INVARIANT (this);
    return m_metaData;
  }

openInputFile()

StatusCode EL::Worker::openInputFile ( const std::string & inputFileUrl )

overrideprotectedvirtual

open the given input file without processing it

This is mostly to allow the driver to query the number of events in the input file without processing it, usually to determine the range of events to process.

Guarantee

basic

Failures

file can't be opened

Implements EL::Detail::IInputModuleActions.

Definition at line 667 of file Worker.cxx.

  {
    using namespace msgEventLoop;
 
    // Enable custom error handling in a nice way
    RootUtils::WithRootErrorHandler my_handler( fileOpenErrorFilter );
 
    RCU_CHANGE_INVARIANT (this);
 
    if (m_inputFileUrl == inputFileUrl)
      return ::StatusCode::SUCCESS;
 
    if (!m_inputFileUrl.empty())
    {
      if (m_newInputFile == false)
      {
        for (auto& module : m_modules)
          ANA_CHECK (module->onCloseInputFile (*this));
        for (auto& module : m_modules)
          ANA_CHECK (module->postCloseInputFile (*this));
      }
      m_newInputFile   = false;
      m_hasInputEvents = false;
      m_inputTree      = nullptr;
      m_inputFile.reset ();
      m_inputFileUrl.clear ();
    }
 
    if (inputFileUrl.empty())
      return ::StatusCode::SUCCESS;
 
    ANA_MSG_INFO ("Opening file " << inputFileUrl);
    std::unique_ptr<TFile> inputFile;
    try
    {
      inputFile = SH::openFile (inputFileUrl, *metaData());
    } catch (...)
    {
      Detail::report_exception (std::current_exception());
    }
    if (inputFile.get() == 0)
    {
      ANA_MSG_ERROR ("failed to open file " << inputFileUrl);
      for (auto& module : m_modules)
        module->reportInputFailure (*this);
      return ::StatusCode::FAILURE;
    }
    if (inputFile->IsZombie())
    {
      ANA_MSG_ERROR ("input file is a zombie: " << inputFileUrl);
      for (auto& module : m_modules)
        module->reportInputFailure (*this);
      return ::StatusCode::FAILURE;
    }
 
    // Direct TTree access 
    TTree *tree = 0;
    const std::string treeName
      = m_metaData->castString (SH::MetaFields::treeName, SH::MetaFields::treeName_default);
    tree = dynamic_cast<TTree*>(inputFile->Get (treeName.c_str()));
    if (tree == nullptr)
    {
      ANA_MSG_INFO ("tree " << treeName << " not found in input file: " << inputFileUrl);
      ANA_MSG_INFO ("treating this like a tree with no events");
    }
    else {
      m_hasInputEvents = (tree->GetEntries() > 0);
    }
 
    m_newInputFile = true;
    m_inputTree = tree;
    m_inputEntry = 0;
    m_inputFile = std::move (inputFile);
    m_inputFileUrl = inputFileUrl;
 
    // onFirstInputFile to setup Event object
    if (m_firstInputFile)
    {
      for (auto& module : m_modules)
        ANA_CHECK (module->onFirstInputFile (*this));
      m_firstInputFile = false;
    }
    else {
      for (auto& module : m_modules)
        ANA_CHECK (module->onNextInputFile (*this));
    }
 
    // Check if we have input events - done above for TTree
    if (m_inputTree == nullptr) {
      if (m_event) m_hasInputEvents = (m_event->getEntries() > 0);
    }
 
    return ::StatusCode::SUCCESS;
  }

processEvents()

StatusCode EL::Worker::processEvents ( EventRange & eventRange )

overrideprotectedvirtual

process the given event range

This will update eventRange if the end is set to eof

Guarantee

basic

Failures

file can't be opened
event range exceeds length of file
processing failures

Implements EL::Detail::IInputModuleActions.

Definition at line 567 of file Worker.cxx.

  {
    using namespace msgEventLoop;
 
    RCU_CHANGE_INVARIANT (this);
    RCU_REQUIRE (!eventRange.m_url.empty());
    RCU_REQUIRE (eventRange.m_beginEvent >= 0);
    RCU_REQUIRE (eventRange.m_endEvent == EventRange::eof || eventRange.m_endEvent >= eventRange.m_beginEvent);
 
    ANA_CHECK (openInputFile (eventRange.m_url));
 
    if (eventRange.m_beginEvent > inputFileNumEntries())
    {
      ANA_MSG_ERROR ("first event (" << eventRange.m_beginEvent << ") points beyond last event in file (" << inputFileNumEntries() << ")");
      return ::StatusCode::FAILURE;
    }
    if (eventRange.m_endEvent == EventRange::eof)
    {
      eventRange.m_endEvent = inputFileNumEntries();
    } else if (eventRange.m_endEvent > inputFileNumEntries())
    {
      ANA_MSG_ERROR ("end event (" << eventRange.m_endEvent << ") points beyond last event in file (" << inputFileNumEntries() << ")");
      return ::StatusCode::FAILURE;
    }
 
    m_inputEntry = eventRange.m_beginEvent;
 
    if (m_algorithmsInitialized == false)
    {
      for (auto& module : m_modules)
        ANA_CHECK (module->onInitialize (*this));
      m_algorithmsInitialized = true;
    }
 
    if (m_newInputFile)
    {
      m_newInputFile = false;
      for (auto& module : m_modules)
        ANA_CHECK (module->onNewInputFile (*this));
    }
 
    if (eventRange.m_beginEvent == 0)
    {
      for (auto& module : m_modules)
        ANA_CHECK (module->onFileExecute (*this));
    }
 
    ANA_MSG_INFO ("Processing events " << eventRange.m_beginEvent << "-" << eventRange.m_endEvent << " in file " << eventRange.m_url);
 
    for (uint64_t event = eventRange.m_beginEvent;
         event != uint64_t (eventRange.m_endEvent);
         ++ event)
    {
      m_inputEntry = event;
      for (auto& module : m_modules)
      {
        if (module->onExecute (*this).isFailure())
        {
          ANA_MSG_ERROR ("processing event " << treeEntry() << " on file " << inputFileName());
          return ::StatusCode::FAILURE;
        }
      }
      if (m_firstEvent)
      {
        m_firstEvent = false;
        for (auto& module : m_modules)
          ANA_CHECK (module->postFirstEvent (*this));
      }
      m_eventsProcessed += 1;
      if (m_eventsProcessed % 10000 == 0)
        ANA_MSG_INFO ("Processed " << m_eventsProcessed << " events");
    }
    return ::StatusCode::SUCCESS;
  }

processInputs()

StatusCode EL::Worker::processInputs ( )

protected

process all the inputs

This method ought to be called after initialize and before finalize. It will rely on the defined modules to steer it to the files and events it ought to process.

Definition at line 499 of file Worker.cxx.

  {
    using namespace msgEventLoop;
 
    RCU_CHANGE_INVARIANT (this);
 
    for (auto& module : m_modules) 
      ANA_CHECK (module->processInputs (*this, *this));
 
    return ::StatusCode::SUCCESS;
  }

setFilterPassed()

void EL::Worker::setFilterPassed ( bool val_filterPassed )

finaloverridevirtualnoexcept

set the value of filterPassed

Guarantee

no-fail

Implements EL::IFilterWorker.

Definition at line 323 of file Worker.cxx.

  {
    RCU_CHANGE_INVARIANT (this);
    m_skipEvent = !val_filterPassed;
  }

setJobConfig()

void EL::Worker::setJobConfig ( JobConfig && jobConfig )

protected

set the JobConfig

This takes care of adding the algorithms, etc. (only algorithms for now, 03 Feb 17).

Note the rvalue calling convention here: Algorithms are objects that get modified, so if you use them more than once you need to copy/clone them. However, in practice no driver should need that (though many do for now, 03 Feb 17), as drivers generally stream the JobConfig in for one-time use.

Guarantee

basic

Failures

job configuration/streaming errors

Definition at line 373 of file Worker.cxx.

  {
    RCU_CHANGE_INVARIANT (this);
    for (auto& alg : jobConfig.extractAlgorithms())
    {
      m_algs.push_back (std::move (alg));
    }
  }

setMetaData()

void EL::Worker::setMetaData ( const SH::MetaObject * val_metaData )

protected

set the metaData

Guarantee

no-fail

Definition at line 342 of file Worker.cxx.

  {
    RCU_CHANGE_INVARIANT (this);
    RCU_REQUIRE (val_metaData != 0);
 
    m_metaData = val_metaData;
  }

setOutputHist()

void EL::Worker::setOutputHist ( const std::string & val_outputTarget )

protected

set the histogram output list

Guarantee

no-fail

Definition at line 353 of file Worker.cxx.

  {
    RCU_CHANGE_INVARIANT (this);
 
    m_outputTarget = val_outputTarget;
  }

setSegmentName()

void EL::Worker::setSegmentName ( const std::string & val_segmentName )

protected

set the segment name

Guarantee

no-fail

Definition at line 363 of file Worker.cxx.

  {
    RCU_CHANGE_INVARIANT (this);
 
    m_segmentName = val_segmentName;
  }

skipEvent()

void EL::Worker::skipEvent ( )

overridevirtual

effects: skip the current event, i.e.

skip the rest of the algorithms for this event guarantee: no-fail rationale: if you have an analysis strategy in which you divide work into multiple algorithms you may want to have dedicated algorithms for event selection that then skip later algorithms that fill histograms

Implements EL::IWorker.

Definition at line 305 of file Worker.cxx.

  {
    RCU_CHANGE_INVARIANT (this);
    m_skipEvent = true;
  }

testInvariant()

void EL::Worker::testInvariant

(

)

const

effects: test the invariant of this object guarantee: no-fail

Definition at line 68 of file Worker.cxx.

  {
    for (std::size_t iter = 0, end = m_algs.size(); iter != end; ++ iter)
    {
      RCU_INVARIANT (m_algs[iter].m_algorithm != nullptr);
    }
  }

tree()

TTree * EL::Worker::tree ( ) const

overridevirtual

description: the tree we are running on guarantee: no-fail

Implements EL::IWorker.

Definition at line 206 of file Worker.cxx.

  {
    RCU_READ_INVARIANT (this);
    return m_inputTree;
  }

treeEntry()

Long64_t EL::Worker::treeEntry ( ) const

overridevirtual

description: the entry in the tree we are reading guarantee: no-fail

Implements EL::IWorker.

Definition at line 215 of file Worker.cxx.

  {
    RCU_READ_INVARIANT (this);
    return m_inputEntry;
  }

triggerConfig()

TTree * EL::Worker::triggerConfig ( ) const

overridevirtual

description: the trigger config tree from the input file, or NULL if we did not find it guarantee: strong failures: i/o errors

Implements EL::IWorker.

Definition at line 256 of file Worker.cxx.

  {
    RCU_READ_INVARIANT (this);
    if (inputFile() == nullptr)
      throw std::runtime_error ("no input file is currently open");
    return dynamic_cast<TTree*>(inputFile()->Get("physicsMeta/TrigConfTree"));
  }

xaodEvent()

xAOD::Event * EL::Worker::xaodEvent ( ) const

overridevirtual

description: the xAOD event and store guarantee: strong failures: out of memory I failures: EventSvc not configured postcondition: result != 0

Implements EL::IWorker.

Definition at line 267 of file Worker.cxx.

  {
    RCU_READ_INVARIANT (this);
 
    if (m_event == nullptr)
      throw std::runtime_error ("Worker::xaodEvent: Job not configured for xAOD support");
    return m_event;
  }

xaodStore()

xAOD::TStore * EL::Worker::xaodStore ( ) const

overridevirtual

Implements EL::IWorker.

Definition at line 279 of file Worker.cxx.

  {
    RCU_READ_INVARIANT (this);
 
    if (m_tstore == nullptr)
      throw std::runtime_error ("Worker::xaodStore: Job not configured for xAOD support");
    return m_tstore;
  }

Member Data Documentation

m_algorithmsInitialized

bool EL::Worker::m_algorithmsInitialized {false}

private

whether the algorithms are initialized

Definition at line 427 of file Worker.h.

{false};

m_algs

std::vector<Detail::AlgorithmData> EL::Detail::ModuleData::m_algs

inherited

the list of algorithms

Definition at line 66 of file ModuleData.h.

m_batchJob

BatchJob* EL::Detail::ModuleData::m_batchJob = nullptr

inherited

the BatchJob configuration (if used)

Definition at line 115 of file ModuleData.h.

m_event

xAOD::Event* EL::Detail::ModuleData::m_event {nullptr}

inherited

the Event object, if we use one

Definition at line 100 of file ModuleData.h.

{nullptr};

m_eventsProcessed

uint64_t EL::Detail::ModuleData::m_eventsProcessed {0}

inherited

the number of events that have been processed

Definition at line 91 of file ModuleData.h.

{0};

m_evtStore

asg::SgEvent* EL::Detail::ModuleData::m_evtStore {nullptr}

inherited

the SgEvent structure, if we use one

Definition at line 106 of file ModuleData.h.

{nullptr};

m_firstEvent

bool EL::Worker::m_firstEvent {true}

private

whether we are still to process the first event

Definition at line 432 of file Worker.h.

{true};

m_firstInputFile

bool EL::Worker::m_firstInputFile {true}

private

whether this is the first input file

Definition at line 406 of file Worker.h.

{true};

m_hasInputEvents

bool EL::Detail::ModuleData::m_hasInputEvents = false

inherited

flag whether the most recently opened input file has events or not

Definition at line 82 of file ModuleData.h.

m_histOutput

OutputStreamData* EL::Detail::ModuleData::m_histOutput {nullptr}

inherited

the histogram output stream

Definition at line 94 of file ModuleData.h.

{nullptr};

m_inputEntry

uint64_t EL::Detail::ModuleData::m_inputEntry {0}

inherited

the entry in the input tree we are currently looking at

Definition at line 79 of file ModuleData.h.

{0};

m_inputFile

std::unique_ptr<TFile> EL::Detail::ModuleData::m_inputFile

inherited

the input file pointer of the currently opened filed

Definition at line 72 of file ModuleData.h.

m_inputFileUrl

std::string EL::Detail::ModuleData::m_inputFileUrl

inherited

the input file url of the currently opened file

Definition at line 69 of file ModuleData.h.

m_inputTree

TTree* EL::Detail::ModuleData::m_inputTree {nullptr}

inherited

the (main) tree in the input file

Definition at line 75 of file ModuleData.h.

{nullptr};

m_jobStats

std::unique_ptr<TTree> EL::Detail::ModuleData::m_jobStats

inherited

Tree saving per-job statistics information.

Definition at line 97 of file ModuleData.h.

m_metaData

const SH::MetaObject* EL::Detail::ModuleData::m_metaData {nullptr}

inherited

the meta-data we use

Definition at line 88 of file ModuleData.h.

{nullptr};

m_moduleConfig

std::vector<asg::AsgComponentConfig> EL::Worker::m_moduleConfig

private

the module configurations we use

Definition at line 437 of file Worker.h.

m_modules

std::vector<std::unique_ptr<Detail::Module> > EL::Worker::m_modules

private

the list of modules we hold

Definition at line 401 of file Worker.h.

m_newInputFile

bool EL::Worker::m_newInputFile {false}

private

whether this is a new input file (i.e.

one that has not yet been connected to the algorithms)

Definition at line 412 of file Worker.h.

{false};

m_outputs

std::map<std::string,std::shared_ptr<Detail::OutputStreamData> > EL::Detail::ModuleData::m_outputs

inherited

the list of output files

Definition at line 112 of file ModuleData.h.

m_outputTarget

std::string EL::Worker::m_outputTarget

private

the target file to which we will write the histogram output

Definition at line 417 of file Worker.h.

m_segmentName

std::string EL::Worker::m_segmentName

private

the name of the segment we are processing

Definition at line 422 of file Worker.h.

m_skipEvent

bool EL::Detail::ModuleData::m_skipEvent = false

inherited

whether we are skipping the current event

Definition at line 85 of file ModuleData.h.

m_tstore

xAOD::TStore* EL::Detail::ModuleData::m_tstore {nullptr}

inherited

the TStore structure, if we use one

Definition at line 103 of file ModuleData.h.

{nullptr};

m_worker

Worker* EL::Detail::ModuleData::m_worker {nullptr}

inherited

the worker (to pass on to the algorithms)

Definition at line 109 of file ModuleData.h.

{nullptr};

---

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

• Worker.h
• Worker.cxx